From e960a9d0da3e50cd34dff31a6f07f73e516fb82e Mon Sep 17 00:00:00 2001
From: "Florine W. Dekker" <florine@fwdekker.com>
Date: Fri, 20 Oct 2023 00:02:50 +0200
Subject: [PATCH] Use val/var consistently in schemes, rewrite trees

The goal was actually only to fix the usages of `val`s and `var`s across the `Scheme`s (cf. #476), but this ended up in being a major overhaul of how the various `Tree`-related classes work together. I found quite a few pieces of code that were, by themselves, neat, but for which much better solutions existed. With these changes, I feel more confident in the stability of the code, and plenty of docs and tests have been added as well. I am aware that #473 will be another overhaul of the `Tree`s, but that won't be until v3.1.x, and I don't want to wait for that. Also, depending on the solution for that issue, the code here might be retained completely anyway.
---
 README.md                                     |  13 +-
 build.gradle.kts                              |   5 +-
 .../kotlin/com/fwdekker/randomness/Bundle.kt  |   2 +-
 .../com/fwdekker/randomness/SchemeEditor.kt   |   2 +-
 .../com/fwdekker/randomness/Settings.kt       |  42 +-
 .../kotlin/com/fwdekker/randomness/State.kt   |  40 +-
 .../fwdekker/randomness/template/Template.kt  |   2 +-
 .../template/TemplateActionLoader.kt          |   3 +-
 .../randomness/template/TemplateActions.kt    |  24 +-
 .../randomness/template/TemplateJTree.kt      | 282 ++++----
 .../randomness/template/TemplateJTreeModel.kt | 287 ++++-----
 .../randomness/template/TemplateList.kt       |   9 +-
 .../template/TemplateListConfigurable.kt      |  23 +-
 .../randomness/template/TemplateListEditor.kt | 124 ++--
 .../randomness/template/TemplateReference.kt  |   5 +
 .../fwdekker/randomness/ui/PreviewPanel.kt    |   4 +-
 .../randomness/word/WordSchemeEditor.kt       |  13 +-
 src/main/resources/randomness.properties      |  23 +-
 .../com/fwdekker/randomness/SettingsTest.kt   |  27 +-
 .../com/fwdekker/randomness/StateTest.kt      |  42 --
 .../template/TemplateJTreeModelTest.kt        | 594 ++++++++---------
 .../randomness/template/TemplateJTreeTest.kt  | 604 +++++++++++-------
 .../template/TemplateListEditorTest.kt        |  48 +-
 .../randomness/testhelpers/Dummies.kt         |   2 +-
 .../randomness/ui/PreviewPanelTest.kt         |   3 +-
 .../randomness/word/WordSchemeEditorTest.kt   |   3 +-
 26 files changed, 1166 insertions(+), 1060 deletions(-)

diff --git a/README.md b/README.md
index 0574d9651..f6cc4c228 100644
--- a/README.md
+++ b/README.md
@@ -100,11 +100,22 @@ See [Plugin Signing](https://plugins.jetbrains.com/docs/intellij/plugin-signing.
 ```bash
 $ gradlew test                    # Run tests
 $ gradlew test --tests X          # Run tests in class X (package name optional)
-$ gradlew test --kotest.tags="X"  # Run tests with `NamedTag` X (also supports not (!), and (&), or (|))
+$ gradlew test -Pkotest.tags="X"  # Run tests with `NamedTag` X (also supports not (!), and (&), or (|))
 $ gradlew check                   # Run tests and static analysis
 $ gradlew runPluginVerifier       # Check for compatibility issues
 ```
 
+#### 🏷️ Filtering tests
+[Kotest tests can be tagged](https://kotest.io/docs/framework/tags.html) to allow selectively running tests.
+Tag an entire test class by adding `tags(...)` to the class definition, or tag an individual test `context` by
+writing `context("foo").config(tags = setOf(...)) {`.
+It is not possible to tag an individual `test` due to limitations in Kotest.
+
+To run only one `context` in some test class `X`, prefix the `context`'s name with `f:` and run with `--tests X`.
+The prefix `f:` filters out other `context`s in that test class, and `--tests X` filters out other test classes.
+Alternatively, tag the desired `context` with the `Focus` tag and run with `-Pkotest.tags="Focus"` to filter by that
+tag.
+
 ### 📚 Documentation
 ```bash
 $ gradlew dokkaHtml  # Generate documentation
diff --git a/build.gradle.kts b/build.gradle.kts
index 645a27793..13360b49c 100644
--- a/build.gradle.kts
+++ b/build.gradle.kts
@@ -105,7 +105,10 @@ tasks {
         if (project.hasProperty("kotest.tags")) systemProperty("kotest.tags", project.findProperty("kotest.tags")!!)
 
         useJUnitPlatform {
-            includeEngines("junit-vintage", "kotest")
+            if (!project.hasProperty("kotest.tags"))
+                includeEngines("junit-vintage")
+
+            includeEngines("kotest")
         }
 
         testLogging {
diff --git a/src/main/kotlin/com/fwdekker/randomness/Bundle.kt b/src/main/kotlin/com/fwdekker/randomness/Bundle.kt
index 20f263aa2..5fac53f29 100644
--- a/src/main/kotlin/com/fwdekker/randomness/Bundle.kt
+++ b/src/main/kotlin/com/fwdekker/randomness/Bundle.kt
@@ -38,7 +38,7 @@ object Bundle {
  * @throws java.util.MissingFormatArgumentException if [args] has fewer arguments than required for [format]
  */
 fun String.matchesFormat(format: String, vararg args: String) =
-    Regex("%[0-9]+\\\$[Ss]").findAll(format)
+    Regex("%[0-9]+\\\$[Ssd]").findAll(format)
         .toList()
         .reversed()
         .fold(format) { acc, match ->
diff --git a/src/main/kotlin/com/fwdekker/randomness/SchemeEditor.kt b/src/main/kotlin/com/fwdekker/randomness/SchemeEditor.kt
index 73af73a92..7f0f421e1 100644
--- a/src/main/kotlin/com/fwdekker/randomness/SchemeEditor.kt
+++ b/src/main/kotlin/com/fwdekker/randomness/SchemeEditor.kt
@@ -76,5 +76,5 @@ abstract class SchemeEditor<S : Scheme>(val scheme: S) : Disposable {
     /**
      * Disposes this editor's resources.
      */
-    override fun dispose() = Disposer.dispose(this)
+    override fun dispose() = decoratorEditors.forEach { Disposer.dispose(it) }
 }
diff --git a/src/main/kotlin/com/fwdekker/randomness/Settings.kt b/src/main/kotlin/com/fwdekker/randomness/Settings.kt
index 420bfb784..74785bfc0 100644
--- a/src/main/kotlin/com/fwdekker/randomness/Settings.kt
+++ b/src/main/kotlin/com/fwdekker/randomness/Settings.kt
@@ -8,6 +8,7 @@ import com.intellij.openapi.components.SettingsCategory
 import com.intellij.openapi.components.Storage
 import com.intellij.openapi.components.service
 import com.intellij.util.xmlb.XmlSerializer
+import com.intellij.util.xmlb.annotations.OptionTag
 import com.intellij.util.xmlb.annotations.Transient
 import org.jdom.Element
 import java.lang.module.ModuleDescriptor
@@ -22,7 +23,8 @@ import com.intellij.openapi.components.State as JBState
  */
 data class Settings(
     var version: String = CURRENT_VERSION,
-    var templateList: TemplateList = TemplateList(),
+    @OptionTag
+    val templateList: TemplateList = TemplateList(),
 ) : State() {
     /**
      * @see TemplateList.templates
@@ -31,19 +33,25 @@ data class Settings(
     val templates: MutableList<Template> get() = templateList.templates
 
 
-    override fun doValidate() = templateList.doValidate()
-
-    override fun deepCopy(retainUuid: Boolean) =
-        copy(templateList = templateList.deepCopy(retainUuid = retainUuid)).deepCopyTransient(retainUuid)
+    init {
+        applyContext(this)
+    }
 
-    override fun copyFrom(other: State) {
-        require(other is Settings) { "Cannot copy from different type." }
 
-        this.templateList.copyFrom(other.templateList)
-        copyFromTransient(other)
+    override fun applyContext(context: Box<Settings>) {
+        super.applyContext(context)
+        templateList.applyContext(context)
     }
 
 
+    override fun doValidate() = templateList.doValidate()
+
+    override fun deepCopy(retainUuid: Boolean) =
+        copy(templateList = templateList.deepCopy(retainUuid = retainUuid))
+            .deepCopyTransient(retainUuid)
+            .also { it.applyContext(it) }
+
+
     /**
      * Holds constants.
      */
@@ -51,7 +59,8 @@ data class Settings(
         /**
          * The persistent [Settings] instance.
          */
-        val DEFAULT: Settings by lazy { service<PersistentSettings>().settings }
+        val DEFAULT: Settings
+            get() = service<PersistentSettings>().settings
     }
 }
 
@@ -70,11 +79,11 @@ data class Settings(
 )
 class PersistentSettings : PersistentStateComponent<Element> {
     /**
-     * The persistent settings instance.
+     * The [Settings] that should be persisted.
      *
      * @see Settings.DEFAULT Preferred method of accessing the persistent settings instance.
      */
-    val settings = Settings()
+    var settings = Settings()
 
 
     /**
@@ -83,12 +92,11 @@ class PersistentSettings : PersistentStateComponent<Element> {
     override fun getState(): Element = XmlSerializer.serialize(settings)
 
     /**
-     * Deserializes [element] into a [Settings] instance, which is then copied into the [settings] instance.
-     *
-     * @see TemplateList.copyFrom
+     * Deserializes [element] into a [Settings] instance, which is then stored in [settings].
      */
-    override fun loadState(element: Element) =
-        settings.copyFrom(XmlSerializer.deserialize(upgrade(element), Settings::class.java))
+    override fun loadState(element: Element) {
+        settings = XmlSerializer.deserialize(upgrade(element), Settings::class.java)
+    }
 
 
     /**
diff --git a/src/main/kotlin/com/fwdekker/randomness/State.kt b/src/main/kotlin/com/fwdekker/randomness/State.kt
index 5ea9a3014..1fdec454a 100644
--- a/src/main/kotlin/com/fwdekker/randomness/State.kt
+++ b/src/main/kotlin/com/fwdekker/randomness/State.kt
@@ -1,7 +1,6 @@
 package com.fwdekker.randomness
 
 import com.fasterxml.uuid.Generators
-import com.intellij.util.xmlb.XmlSerializerUtil
 import com.intellij.util.xmlb.annotations.Transient
 import kotlin.random.Random
 import kotlin.random.asJavaRandom
@@ -10,9 +9,12 @@ import kotlin.random.asJavaRandom
 /**
  * A state holds variables that can be configured, validated, copied, and loaded.
  *
- * All non-transient non-primitive fields of a state should be immutable references. For example, if a state has a field
- * `list: List<String>`, then `list` should be a `val`, not a `var`, so that references to `state.list` remain valid
- * even after `copyFrom`.
+ * In a [State], fields are typically mutable, because the user can change the field. However, fields that themselves
+ * also contain data (e.g. a [Collection] or a [DecoratorScheme]) should be stored as immutable references (but may
+ * themselves be mutable). For example, instead of having the field `var list: List<String>`, a [State] should have the
+ * field `val list: MutableList<String>`. This reflects the typical case in which the user does not change the reference
+ * to the object, but changes the properties inside the object. And, more importantly, means that nested a
+ * [SchemeEditor] can share a single unchanging reference to a [State] with its nested [SchemeEditor]s.
  */
 abstract class State {
     /**
@@ -58,7 +60,7 @@ abstract class State {
      *
      * Fields annotated with [Transient] are shallow-copied.
      *
-     * @see deepCopyTransient utility function for subclasses that want to implement `deepCopy`
+     * @see deepCopyTransient utility function for subclasses that want to implement [deepCopy]
      */
     abstract fun deepCopy(retainUuid: Boolean = false): State
 
@@ -73,34 +75,8 @@ abstract class State {
         val thiz: State = this@State
 
         if (retainUuid) self.uuid = thiz.uuid
-        self.applyContext(thiz.context.copy())
+        self.applyContext(thiz.context.copy()) // Copies the [Box], not the context itself
 
         return self
     }
-
-    /**
-     * Copies [other] into `this`.
-     *
-     * Works by shallow-copying a [deepCopy] of [other] into `this`. [Transient] fields are shallow-copied directly from
-     * [other] instead.
-     *
-     * Implementations may choose to shallow-copy additional fields directly from [other].
-     *
-     * @param other the state to copy into `this`; should be a (sub)class of this state
-     * @see copyFromTransient utility function for subclasses that want to implement `copyFrom`
-     */
-    open fun copyFrom(other: State) {
-        XmlSerializerUtil.copyBean(other.deepCopy(retainUuid = true), this)
-        copyFromTransient(other)
-    }
-
-    /**
-     * Copies basic [Transient] fields from [other] into `this`.
-     *
-     * Typically used by subclasses to help implement [copyFrom].
-     */
-    protected fun copyFromTransient(other: State) {
-        this.uuid = other.uuid
-        this.applyContext(other.context.copy())
-    }
 }
diff --git a/src/main/kotlin/com/fwdekker/randomness/template/Template.kt b/src/main/kotlin/com/fwdekker/randomness/template/Template.kt
index 254a5ff5d..4bf926f5a 100644
--- a/src/main/kotlin/com/fwdekker/randomness/template/Template.kt
+++ b/src/main/kotlin/com/fwdekker/randomness/template/Template.kt
@@ -38,7 +38,7 @@ data class Template(
             WordScheme::class,
         ]
     )
-    var schemes: MutableList<Scheme> = DEFAULT_SCHEMES,
+    val schemes: MutableList<Scheme> = DEFAULT_SCHEMES,
     val arrayDecorator: ArrayDecorator = DEFAULT_ARRAY_DECORATOR,
 ) : Scheme() {
     override val typeIcon
diff --git a/src/main/kotlin/com/fwdekker/randomness/template/TemplateActionLoader.kt b/src/main/kotlin/com/fwdekker/randomness/template/TemplateActionLoader.kt
index 71b5202f2..d4fb8b2c7 100644
--- a/src/main/kotlin/com/fwdekker/randomness/template/TemplateActionLoader.kt
+++ b/src/main/kotlin/com/fwdekker/randomness/template/TemplateActionLoader.kt
@@ -37,7 +37,8 @@ open class TemplateActionLoader(
         newList: List<Template>,
         actionManager: ActionManager = ActionManager.getInstance(),
     ) {
-        oldList.filterNot { it in newList }.forEach { unregisterAction(actionManager, it) }
+        val newUuidList = newList.map { it.uuid }
+        oldList.filterNot { it.uuid in newUuidList }.forEach { unregisterAction(actionManager, it) }
         newList.forEach { registerAction(actionManager, it) }
     }
 
diff --git a/src/main/kotlin/com/fwdekker/randomness/template/TemplateActions.kt b/src/main/kotlin/com/fwdekker/randomness/template/TemplateActions.kt
index f922e52f9..f734b439c 100644
--- a/src/main/kotlin/com/fwdekker/randomness/template/TemplateActions.kt
+++ b/src/main/kotlin/com/fwdekker/randomness/template/TemplateActions.kt
@@ -8,12 +8,14 @@ import com.fwdekker.randomness.Timely.generateTimely
 import com.fwdekker.randomness.array.ArrayDecorator
 import com.fwdekker.randomness.array.ArrayDecoratorEditor
 import com.fwdekker.randomness.ui.PreviewPanel
+import com.intellij.openapi.Disposable
 import com.intellij.openapi.actionSystem.ActionGroup
 import com.intellij.openapi.actionSystem.ActionUpdateThread
 import com.intellij.openapi.actionSystem.AnAction
 import com.intellij.openapi.actionSystem.AnActionEvent
 import com.intellij.openapi.options.Configurable
 import com.intellij.openapi.options.ShowSettingsUtil
+import com.intellij.openapi.util.Disposer
 import java.awt.BorderLayout
 import javax.swing.JPanel
 
@@ -128,9 +130,13 @@ class TemplateInsertAction(
      *
      * @param arrayDecorator the decorator being edited in this configurable
      */
-    inner class ArrayDecoratorConfigurable(arrayDecorator: ArrayDecorator) : Configurable {
-        private val editor = ArrayDecoratorEditor(arrayDecorator, embedded = true)
-        private val previewPanel = PreviewPanel { template.deepCopy().also { it.arrayDecorator.enabled = true } }
+    inner class ArrayDecoratorConfigurable(arrayDecorator: ArrayDecorator) : Configurable, Disposable {
+        private val editor =
+            ArrayDecoratorEditor(arrayDecorator, embedded = true)
+                .also { Disposer.register(this, it) }
+        private val previewPanel =
+            PreviewPanel { template.deepCopy().also { it.arrayDecorator.enabled = true } }
+                .also { Disposer.register(this, it) }
 
 
         init {
@@ -170,12 +176,14 @@ class TemplateInsertAction(
         override fun getDisplayName() = text
 
         /**
-         * Disposes the [editor] and [previewPanel].
+         * Recursively disposes this configurable's resources.
          */
-        override fun disposeUIResources() {
-            editor.dispose()
-            previewPanel.dispose()
-        }
+        override fun disposeUIResources() = Disposer.dispose(this)
+
+        /**
+         * Non-recursively disposes this configurable's resources.
+         */
+        override fun dispose() = Unit
     }
 }
 
diff --git a/src/main/kotlin/com/fwdekker/randomness/template/TemplateJTree.kt b/src/main/kotlin/com/fwdekker/randomness/template/TemplateJTree.kt
index da378a9d6..a3dd9f036 100644
--- a/src/main/kotlin/com/fwdekker/randomness/template/TemplateJTree.kt
+++ b/src/main/kotlin/com/fwdekker/randomness/template/TemplateJTree.kt
@@ -2,7 +2,6 @@ package com.fwdekker.randomness.template
 
 import com.fwdekker.randomness.Bundle
 import com.fwdekker.randomness.Scheme
-import com.fwdekker.randomness.Settings
 import com.fwdekker.randomness.datetime.DateTimeScheme
 import com.fwdekker.randomness.decimal.DecimalScheme
 import com.fwdekker.randomness.integer.IntegerScheme
@@ -38,63 +37,70 @@ import kotlin.math.min
 /**
  * A tree containing [Template]s and [Scheme]s.
  *
- * The tree contains the templates and schemes defined in the [TemplateList] of [currentSettings] by loading that list
- * into this tree's [TemplateJTreeModel]. Furthermore, when a new [Scheme] is added or copied, it will use the
- * [currentSettings].
+ * Changes made through this tree's interface (e.g. adding, removing, copying) are immediately reflected in the
+ * [currentTemplateList]. The [originalTemplateList] is used only as a reference point to determine what changes have
+ * occurred, for example when [isModified] is called or when the end user requests that changes are (partially)
+ * reverted.
  *
- * This tree reads from [originalSettings] to determine whether particular [Scheme]s have been modified. Modified
- * [Scheme]s can be reset, in which case the original state is copied into that scheme in the [currentSettings].
+ * If changes are made outside of this tree's interface (i.e. by directly operating on the [currentTemplateList]
+ * instance that was passed in the constructor), this tree's internal model becomes desynchronized, and must be
+ * resynchronized by invoking [reload]. Except for [reload], the behaviour of this tree is undefined while
+ * desynchronized.
  *
- * @property originalSettings The original settings before any modifications were made.
- * @property currentSettings The current settings which include modifications.
+ * Internally, the [currentTemplateList] is loaded into a [TemplateJTreeModel]. The [TemplateJTree] class is the
+ * corresponding user interface class, which additionally provides (1) toolbars and buttons for manipulating the model,
+ * (2) node expansion and selection, and (3) handling for tracking and reversing modifications.
+ *
+ * @property originalTemplateList The (read-only) original templates without modifications.
+ * @property currentTemplateList The current templates, including modifications.
  */
+@Suppress("detekt:TooManyFunctions") // Cannot be avoided
 class TemplateJTree(
-    private val originalSettings: Settings,
-    private var currentSettings: Settings,
-) : Tree(TemplateJTreeModel(currentSettings.templateList)) {
+    private val originalTemplateList: TemplateList,
+    private var currentTemplateList: TemplateList,
+) : Tree(TemplateJTreeModel(currentTemplateList)) {
     /**
      * The tree's model.
      *
+     * This field should not be accessed directly by outside classes. (But it's not `private` because the field is very
+     * useful during tests.)
+     *
      * This field cannot be named `model` because this causes an NPE during initialization. This field cannot be named
      * `treeModel` because this name is already taken and cannot be overridden.
      */
-    val myModel: TemplateJTreeModel
+    internal val myModel: TemplateJTreeModel
         get() = super.getModel() as TemplateJTreeModel
 
     /**
      * The currently selected node, or `null` if no node is selected, or `null` if the root is selected.
      */
     val selectedNodeNotRoot: StateNode?
-        get() = (lastSelectedPathComponent as? StateNode)
-            ?.let {
-                if (it == model.root) null
-                else it
-            }
+        get() = (lastSelectedPathComponent as? StateNode)?.let { if (it == model.root) null else it }
 
     /**
-     * The currently selected scheme, or `null` if no scheme is currently selected.
+     * The currently selected scheme (or template), or `null` if no scheme is currently selected.
      *
-     * Setting `null` will select the first template in the tree, or the root if there are no templates.
+     * Setting a scheme that is either `null` or not in the tree will clear the current selection.
      */
     var selectedScheme: Scheme?
         get() = selectedNodeNotRoot?.state as? Scheme
         set(value) {
-            val node = value?.let { StateNode(it) }
+            val descendants = myModel.root.descendants
 
-            setSelectionRow(
-                myModel.nodeToRow(
-                    if (node != null && myModel.root.contains(node)) node
-                    else myModel.root.children.firstOrNull() ?: myModel.root
-                )
-            )
+            if (value == null || StateNode(value) !in descendants)
+                clearSelection()
+            else
+                selectionPath = myModel.getPathToRoot(descendants.single { it == StateNode(value) })
         }
 
     /**
-     * The currently selected template, or `null` if no template is currently selected.
+     * The currently selected template, or the parent of the currently selected non-template scheme, or `null` if no
+     * scheme is currently selected.
      *
-     * If a non-template scheme is currently selected, the template parent of that scheme is returned.
+     * Setting a template that is either `null` or not in the tree will select the first template in the tree, or clears
+     * the selection if the tree is empty.
      *
-     * Setting `null` will select the first template in the tree, or the root if there are no templates.
+     * @see selectedScheme
      */
     var selectedTemplate: Template?
         get() {
@@ -108,22 +114,15 @@ class TemplateJTree(
         }
 
     /**
-     * UUIDs of templates that have explicitly been collapsed by the user.
-     */
-    private val explicitlyCollapsed = mutableSetOf<String>()
-
-    /**
-     * All currently visible nodes in depth-first order.
+     * UUIDs of templates that have explicitly been collapsed.
+     *
+     * Though a [TemplateJTree] knows which rows in the tree have been expanded and collapsed, it does not know by
+     * itself which templates these rows belong to. The tree would normally use the [myModel] to find this out, but that
+     * does not work if the UI and the model have become desynchronized, as is the case during [reload]. Therefore, the
+     * [collapsedNodes] field can be used even while desynchronized to determine which templates are collapsed, and,
+     * in particular, which templates should (not) be expanded after resynchronization.
      */
-    private val visibleNodes: List<StateNode>
-        get() {
-            val hidden = explicitlyCollapsed
-                .mapNotNull { myModel.list.getTemplateByUuid(it) }
-                .flatMap { it.schemes }
-                .map { StateNode(it) }
-                .toSet()
-            return myModel.root.recursiveChildren.minus(hidden)
-        }
+    private val collapsedNodes = currentTemplateList.templates.map { it.uuid }.toMutableSet()
 
 
     init {
@@ -136,23 +135,15 @@ class TemplateJTree(
         setCellRenderer(CellRenderer())
         addTreeWillExpandListener(object : TreeWillExpandListener {
             override fun treeWillExpand(event: TreeExpansionEvent) {
-                explicitlyCollapsed.remove((event.path.lastPathComponent as StateNode).state.uuid)
+                collapsedNodes -= (event.path.lastPathComponent as StateNode).state.uuid
             }
 
             override fun treeWillCollapse(event: TreeExpansionEvent) {
-                explicitlyCollapsed.add((event.path.lastPathComponent as StateNode).state.uuid)
+                collapsedNodes += (event.path.lastPathComponent as StateNode).state.uuid
             }
         })
 
-        myModel.rowToNode = { visibleNodes.getOrNull(it) }
-        myModel.nodeToRow = { visibleNodes.indexOf(it) }
-        myModel.expandAndSelect = {
-            expandNode(it)
-            selectedScheme = it.state as Scheme
-        }
-
-        myModel.list.templates.forEach { expandPath(myModel.getPathToRoot(StateNode(it))) }
-        selectedScheme = null
+        setSelectionRow(0)
     }
 
     /**
@@ -178,56 +169,69 @@ class TemplateJTree(
                 Bundle("shared.action.copy"),
                 Bundle("shared.action.up"),
                 Bundle("shared.action.down"),
-                Bundle("shared.action.reset")
+                Bundle("shared.action.reset"),
             )
             .setForcedDnD()
             .createPanel()
 
 
     /**
-     * Reloads the list of templates in [myModel].
+     * Notifies the tree that external changes have been made to [currentTemplateList], and resynchronizes the tree's
+     * model with the template list.
      *
-     * This is a wrapper around [TemplateJTreeModel.reload] that additionally tries to retain the current selection
-     * and expansion state.
+     * If [changedScheme] is not `null`, then only the part of the model that includes the [changedScheme] is
+     * resynchronized. Otherwise, if [changedScheme] is `null`, the entire model is resynchronized.
+     *
+     * This is a wrapper around [TemplateJTreeModel.fireNodeStructureChanged] that additionally tries to retain the
+     * current selection and expansion state. Any new templates that have been added will initially be collapsed.
+     *
+     * @see runPreservingState
      */
-    fun reload() {
-        val oldSelectedScheme = selectedScheme
+    fun reload(changedScheme: Scheme? = null) {
+        runPreservingState { myModel.fireNodeStructureChanged(changedScheme?.let { StateNode(it) } ?: myModel.root) }
 
-        myModel.reload()
-        myModel.list.templates
-            .filterNot { it.uuid in explicitlyCollapsed }
-            .forEach { expandPath(myModel.getPathToRoot(StateNode(it))) }
-
-        selectedScheme = oldSelectedScheme
+        selectedScheme = selectedScheme ?: currentTemplateList.templates.firstOrNull()
     }
 
+    /**
+     * Expands the [Template]s identified by [uuids], and collapses all other [Template]s.
+     */
+    fun expandNodes(uuids: Collection<String> = currentTemplateList.templates.map { it.uuid }) =
+        myModel.root.children
+            .associateWith { it.state.uuid in uuids }
+            .mapKeys { myModel.getPathToRoot(it.key) }
+            .forEach { (path, shouldExpand) -> setExpandedState(path, shouldExpand) }
+
 
     /**
      * Adds [newScheme] at an appropriate location in the tree based on the currently selected node.
      *
-     * @param newScheme the scheme to add; must be an instance of [Template] if [selectedNodeNotRoot] is `null`
+     * @param newScheme the scheme to add; must be a [Template] if [selectedNodeNotRoot] is `null`
      */
     fun addScheme(newScheme: Scheme) {
-        val newNode = StateNode(newScheme)
         val selectedNode = selectedNodeNotRoot
+        val newNode = StateNode(newScheme)
         if (newScheme is Template) newScheme.name = findUniqueNameFor(newScheme)
 
-        if (selectedNode == null) {
-            require(newScheme is Template) { Bundle("template_list.error.add_template_to_non_root") }
-            myModel.insertNode(myModel.root, newNode)
-        } else if (selectedNode.state is Template) {
-            if (newScheme is Template)
-                myModel.insertNodeAfter(myModel.root, newNode, selectedNode)
-            else
-                myModel.insertNode(selectedNode, newNode)
-        } else {
-            if (newScheme is Template)
-                myModel.insertNodeAfter(myModel.root, newNode, myModel.getParentOf(selectedNode)!!)
-            else
-                myModel.insertNodeAfter(myModel.getParentOf(selectedNode)!!, newNode, selectedNode)
+        runPreservingState {
+            if (selectedNode == null) {
+                myModel.insertNode(myModel.root, newNode)
+            } else if (selectedNode.state is Template) {
+                if (newScheme is Template)
+                    myModel.insertNodeAfter(myModel.root, selectedNode, newNode)
+                else
+                    myModel.insertNode(selectedNode, newNode)
+            } else {
+                if (newScheme is Template)
+                    myModel.insertNodeAfter(myModel.root, myModel.getParentOf(selectedNode)!!, newNode)
+                else
+                    myModel.insertNodeAfter(myModel.getParentOf(selectedNode)!!, selectedNode, newNode)
+            }
         }
 
-        expandNode(newNode)
+        val path = myModel.getPathToRoot(newNode)
+        makeVisible(path)
+        expandPath(path)
         selectedScheme = newScheme
     }
 
@@ -239,17 +243,38 @@ class TemplateJTree(
     fun removeScheme(scheme: Scheme) {
         val node = StateNode(scheme)
         val parent = myModel.getParentOf(node)!!
-        val oldIndex = myModel.getIndexOfChild(parent, node)
+        val oldIndex = parent.children.indexOf(node)
 
-        myModel.removeNode(node)
+        runPreservingState { myModel.removeNode(node) }
 
         selectionPath =
             myModel.getPathToRoot(
                 if (myModel.isLeaf(parent)) parent
-                else myModel.getChild(parent, min(oldIndex, myModel.getChildCount(parent) - 1))
+                else parent.children[min(oldIndex, parent.children.count() - 1)]
             )
     }
 
+    /**
+     * Replaces [oldScheme] with [newScheme] in-place.
+     *
+     * If `newScheme` is `null`, then `oldScheme` is removed without being replaced.
+     */
+    fun replaceScheme(oldScheme: Scheme, newScheme: Scheme?) {
+        if (newScheme == null) {
+            removeScheme(oldScheme)
+            return
+        }
+
+        val oldNode = StateNode(oldScheme)
+        val newNode = StateNode(newScheme)
+        val parent = myModel.getParentOf(oldNode)!!
+
+        runPreservingState {
+            myModel.insertNodeAfter(parent, oldNode, newNode)
+            myModel.removeNode(oldNode)
+        }
+    }
+
     /**
      * Moves [scheme] by one position; down if [moveDown] is `true, and up otherwise.
      *
@@ -258,17 +283,25 @@ class TemplateJTree(
      */
     fun moveSchemeByOnePosition(scheme: Scheme, moveDown: Boolean) {
         val node = StateNode(scheme)
-        val index = myModel.nodeToRow(node)
 
-        myModel.exchangeRows(index, getMoveTargetIndex(scheme, moveDown))
-        // `exchangeRows` expands and selects the moved node
+        runPreservingState {
+            myModel.exchangeRows(
+                myModel.root.descendants.indexOf(node),
+                getMoveTargetIndex(scheme, moveDown)
+            )
+        }
+
+        makeVisible(myModel.getPathToRoot(node))
     }
 
     /**
      * Returns `true` if and only if [moveSchemeByOnePosition] can be invoked with these parameters.
      */
     fun canMoveSchemeByOnePosition(scheme: Scheme, moveDown: Boolean) =
-        myModel.canExchangeRows(myModel.nodeToRow(StateNode(scheme)), getMoveTargetIndex(scheme, moveDown))
+        myModel.canExchangeRows(
+            myModel.root.descendants.indexOf(StateNode(scheme)),
+            getMoveTargetIndex(scheme, moveDown)
+        )
 
     /**
      * Returns the index to which [scheme] is moved (down if [moveDown] is `true`, or up otherwise) when
@@ -277,33 +310,32 @@ class TemplateJTree(
     private fun getMoveTargetIndex(scheme: Scheme, moveDown: Boolean): Int {
         val node = StateNode(scheme)
 
-        if (scheme !is Template)
-            return myModel.nodeToRow(node) + if (moveDown) 1 else -1
+        val children = myModel.root.children
+        val descendants = myModel.root.descendants
+        val diff = if (moveDown) 1 else -1
 
-        val parent = myModel.getParentOf(node)!!
-        val indexInParent = myModel.getIndexOfChild(parent, node)
-        val uncleIndexInParent = indexInParent + if (moveDown) 1 else -1
-
-        return if (uncleIndexInParent !in 0 until myModel.getChildCount(parent)) -1
-        else myModel.nodeToRow(myModel.getChild(parent, uncleIndexInParent))
+        return if (scheme !is Template) descendants.indexOf(node) + diff
+        else descendants.indexOf(children.getOrNull(children.indexOf(node) + diff))
     }
 
 
     /**
-     * Expands the path to [node] even if it is a leaf node.
+     * Runs [lambda] while ensuring that the [selectedScheme] and [collapsedNodes] remain unchanged.
      */
-    private fun expandNode(node: StateNode?) {
-        if (node == null) return
+    private fun runPreservingState(lambda: () -> Unit) {
+        val oldSelected = selectedScheme
+        val oldCollapsed = collapsedNodes
 
-        val path = myModel.getPathToRoot(node)
-        expandPath(path.parentPath)
-        expandPath(path)
+        lambda()
+
+        expandNodes(currentTemplateList.templates.map { it.uuid }.toSet() - oldCollapsed)
+        selectedScheme = oldSelected
     }
 
     /**
-     * Returns `true` if and only if [scheme] has been modified with respect to [originalSettings].
+     * Returns `true` if and only if [scheme] has been modified with respect to [originalTemplateList].
      */
-    private fun isModified(scheme: Scheme) = originalSettings.templateList.getSchemeByUuid(scheme.uuid) != scheme
+    private fun isModified(scheme: Scheme) = originalTemplateList.getSchemeByUuid(scheme.uuid) != scheme
 
     /**
      * Finds a good, unique name for [template] so that it can be inserted into this list without conflict.
@@ -313,7 +345,7 @@ class TemplateJTree(
      * number is taken as the starting number.
      */
     private fun findUniqueNameFor(template: Template): String {
-        val templateNames = myModel.list.templates.map { it.name }
+        val templateNames = currentTemplateList.templates.map { it.name }
         if (template.name !in templateNames) return template.name
 
         var i = 1
@@ -354,7 +386,7 @@ class TemplateJTree(
             icon = scheme.icon
 
             if (scheme is Template) {
-                val index = myModel.list.templates.indexOf(scheme) + 1
+                val index = currentTemplateList.templates.indexOf(scheme) + 1
                 if (index <= INDEXED_TEMPLATE_COUNT)
                     append("${index % INDEXED_TEMPLATE_COUNT} ", SimpleTextAttributes.GRAYED_SMALL_ATTRIBUTES, false)
             }
@@ -444,7 +476,7 @@ class TemplateJTree(
              */
             override fun onChosen(value: Scheme?, finalChoice: Boolean): PopupStep<*>? {
                 if (value != null)
-                    addScheme(value.deepCopy().also { it.applyContext(currentSettings) })
+                    addScheme(value.deepCopy().also { it.applyContext(currentTemplateList.context) })
 
                 return null
             }
@@ -506,7 +538,7 @@ class TemplateJTree(
          * Ineligible [Template]s are automatically filtered out.
          */
         private inner class ReferencesPopupStep : AbstractPopupStep(
-            currentSettings.templates
+            currentTemplateList.templates
                 .filter { selectedTemplate!!.canReference(it) }
                 .map { TemplateReference(it.uuid) }
         )
@@ -524,7 +556,7 @@ class TemplateJTree(
         /**
          * Returns `true` if and only if this action is enabled.
          */
-        override fun isEnabled() = selectedNodeNotRoot != null
+        override fun isEnabled() = selectedScheme != null
 
         /**
          * Returns the shortcut for this action.
@@ -553,19 +585,14 @@ class TemplateJTree(
          *
          * @return `true` if and only if this action is enabled
          */
-        override fun isEnabled() = selectedNodeNotRoot != null
+        override fun isEnabled() = selectedScheme != null
 
         /**
          * Copies the selected scheme in the tree.
          *
          * @param event ignored
          */
-        override fun actionPerformed(event: AnActionEvent) {
-            val copy = selectedScheme!!.deepCopy()
-            copy.applyContext(currentSettings)
-
-            addScheme(copy)
-        }
+        override fun actionPerformed(event: AnActionEvent) = addScheme(selectedScheme!!.deepCopy())
     }
 
     /**
@@ -641,23 +668,8 @@ class TemplateJTree(
          *
          * @param event ignored
          */
-        override fun actionPerformed(event: AnActionEvent) {
-            val toReset = selectedScheme!!
-            val toResetFrom = originalSettings.templateList.getSchemeByUuid(toReset.uuid)
-            if (toResetFrom == null) {
-                removeScheme(toReset)
-                return
-            }
-
-            toReset.copyFrom(toResetFrom)
-            toReset.applyContext(currentSettings)
-
-            myModel.fireNodeChanged(StateNode(toReset))
-            myModel.fireNodeStructureChanged(StateNode(toReset))
-
-            clearSelection()
-            myModel.expandAndSelect(StateNode(toReset))
-        }
+        override fun actionPerformed(event: AnActionEvent) =
+            selectedScheme!!.let { replaceScheme(it, originalTemplateList.getSchemeByUuid(it.uuid)) }
     }
 
 
diff --git a/src/main/kotlin/com/fwdekker/randomness/template/TemplateJTreeModel.kt b/src/main/kotlin/com/fwdekker/randomness/template/TemplateJTreeModel.kt
index d3959cc92..ffa55f91d 100644
--- a/src/main/kotlin/com/fwdekker/randomness/template/TemplateJTreeModel.kt
+++ b/src/main/kotlin/com/fwdekker/randomness/template/TemplateJTreeModel.kt
@@ -16,15 +16,8 @@ import javax.swing.tree.TreePath
  * The underlying model of the [TemplateJTree], which synchronizes its state with a [TemplateList] so that modifications
  * to the model appear in the list and vice versa.
  *
- * If the list is modified externally, this model should be notified. The entire model can be refreshed or a different
- * list can be loaded using [reload]. Otherwise, use the `fire` methods such as [fireNodeChanged] to inform of partial
- * changes.
- *
- * The various [State]s that are contained in the [TemplateList] are hierarchically structured as [StateNode]s. As long
- * as the appropriate events are fired when external modifications are made to the [TemplateList], this model provides a
- * number of consistency guarantees. Firstly, the root node is always a [TemplateList], second-level nodes are always
- * [Template]s, and third-level nodes are always [Scheme]s. Secondly, except for the root node, all nodes that are
- * contained in this model have a parent.
+ * If the list is modified externally, this model should be notified using a `fire` method (e.g. [fireNodeChanged]).
+ * Except for the `fire` methods, the behavior of this model is undefined while uninformed of external changes.
  *
  * @param list the list to be modeled
  */
@@ -36,116 +29,126 @@ class TemplateJTreeModel(list: TemplateList = TemplateList(mutableListOf())) : T
     private val treeModelListeners = mutableListOf<TreeModelListener>()
 
     /**
-     * The list that is modeled by this model.
-     *
-     * Replace or re-synchronize the list by invoking [reload].
+     * The root of the tree, containing the original [TemplateList].
      */
-    var list: TemplateList = list
-        private set
+    private val root = StateNode(list)
 
     /**
-     * Returns the node at the given row index, considering which nodes are currently collapsed, ignoring the root.
-     *
-     * Used to implement [EditableModel].
+     * The list of all [StateNode]s in this tree.
      */
-    var rowToNode: (Int) -> StateNode? = { root.recursiveChildren.getOrNull(it) }
+    private val nodes get() = listOf(root) + root.descendants
+
 
     /**
-     * Returns the row index of the given node, considering which nodes are currently collapsed, ignoring the root, or
-     * `-1` if the node could not be found.
-     *
-     * Used to implement [EditableModel].
+     * Returns [root].
      */
-    var nodeToRow: (StateNode?) -> Int = { root.recursiveChildren.indexOf(it) }
+    override fun getRoot() = root
+
 
     /**
-     * Expands and selects the given node.
+     * Not implemented because this method is used only if this is a model for a table.
      *
-     * Used to implement [EditableModel].
+     * @throws UnsupportedOperationException always
      */
-    var expandAndSelect: (StateNode) -> Unit = {}
-
+    @Throws(UnsupportedOperationException::class)
+    override fun addRow() = throw UnsupportedOperationException()
 
     /**
-     * Returns [list] as a [StateNode].
+     * Not implemented because this method is used only if this is a model for a table.
+     *
+     * @throws UnsupportedOperationException always
      */
-    override fun getRoot() = StateNode(list)
+    @Throws(UnsupportedOperationException::class)
+    override fun removeRow(index: Int) = throw UnsupportedOperationException()
+
 
     /**
-     * Reloads the entire model's structure to synchronize it with the state of [newList].
+     * Inserts [child] as the [index]th child of [parent].
      *
-     * Use this method if the entire model should be reloaded from the list because major changes have been made. If
-     * small changes have been made, consider using one of the `fire` methods such as [fireNodeChanged] instead.
+     * Throws an exception if [index] is out of bounds in [parent] (of course allowing [index] to equal the
+     * [getChildCount] of [parent]).
      */
-    fun reload(newList: TemplateList = list) {
-        list = newList
+    fun insertNode(parent: StateNode, child: StateNode, index: Int = getChildCount(parent)) {
+        require(parent in nodes) { Bundle("template_list.error.node_not_in_tree") }
+        require(parent.canHaveChild(child)) { Bundle("template_list.error.wrong_child_type") }
 
-        fireNodeStructureChanged(root)
-    }
+        parent.children = parent.children.toMutableList().also { it.add(index, child) }
 
+        if (parent == root && parent.children.count() == 1)
+            fireNodeStructureChanged(root)
+        else
+            fireNodeInserted(child, parent, index)
+    }
 
     /**
-     * Not implemented because this method is used only if this is a model for a table.
+     * Inserts [child] as a child into [parent] right after [after].
      *
-     * @throws UnsupportedOperationException always
+     * Throws an exception if [after] is not a child of [parent].
      */
-    @Throws(UnsupportedOperationException::class)
-    override fun addRow() =
-        throw UnsupportedOperationException(Bundle("template_list.error.add_empty_row"))
+    fun insertNodeAfter(parent: StateNode, after: StateNode, child: StateNode) {
+        require(after in parent.children) { Bundle("template_list.error.wrong_parent") }
+
+        insertNode(parent, child, parent.children.indexOf(after) + 1)
+    }
 
     /**
-     * Not implemented because this method is used only if this is a model for a table.
+     * Removes [node] from this model.
      *
-     * @throws UnsupportedOperationException always
+     * Throws an exception if [node] is not contained in this model, or if [node] is [getRoot].
      */
-    @Throws(UnsupportedOperationException::class)
-    override fun removeRow(index: Int) =
-        throw UnsupportedOperationException(Bundle("template_list.error.remove_row_by_index"))
+    fun removeNode(node: StateNode) {
+        require(node in nodes) { Bundle("template_list.error.node_not_in_tree") }
+        require(node != root) { Bundle("template_list.error.cannot_remove_root") }
+
+        val parent = getParentOf(node)!!
+        val oldIndex = parent.children.indexOf(node)
+
+        parent.children = parent.children.toMutableList().also { it.remove(node) }
+        fireNodeRemoved(node, parent, oldIndex)
+    }
 
     /**
-     * Exchanges two consecutive rows, moving the node at row [oldIndex] to row [newIndex], and expands and selects the
-     * moved node.
-     *
-     * Indices are looked up using [rowToNode], and are typically relative to the current expansion state of the view.
+     * Exchanges two consecutive rows, moving the node at row [oldIndex] to row [newIndex].
      *
      * If [oldIndex] and [newIndex] both refer to a template or both refer to a scheme, then the node at [oldIndex] will
      * be inserted so that it has the same index in its parent as the node at [newIndex] had before invoking this
-     * method. Otherwise, if [oldIndex] is a non-template scheme and [newIndex] is a template, then the non-template
-     * scheme is moved to the template at [newIndex]; if [oldIndex] is less than [newIndex] then the non-template scheme
-     * becomes the template's first child, otherwise it becomes the template's last child.
+     * method. Otherwise, if [oldIndex] refers to a non-template scheme and [newIndex] refers to a template, then the
+     * non-template scheme is moved into the template at [newIndex]; specifically, if [oldIndex] is less than [newIndex]
+     * then the non-template scheme becomes the template's first child, otherwise it becomes the template's last child.
      */
     override fun exchangeRows(oldIndex: Int, newIndex: Int) {
-        val nodeToMove = rowToNode(oldIndex)!!
-        val targetNode = rowToNode(newIndex)!!
+        require(canExchangeRows(oldIndex, newIndex)) {
+            Bundle("template_list.error.cannot_swap_rows", oldIndex, newIndex)
+        }
+
+        val nodeToMove = root.descendants[oldIndex]
+        val targetNode = root.descendants[newIndex]
 
         val targetNodeParent: StateNode
         val targetIndexInParent: Int
         if (nodeToMove.state !is Template && targetNode.state is Template) {
             if (newIndex < oldIndex) {
-                targetNodeParent = getChild(root, getIndexOfChild(root, targetNode) - 1)
-                targetIndexInParent = getChildCount(targetNodeParent)
+                targetNodeParent = root.children[root.children.indexOf(targetNode) - 1]
+                targetIndexInParent = targetNodeParent.children.count()
             } else {
                 targetNodeParent = targetNode
                 targetIndexInParent = 0
             }
         } else {
             targetNodeParent = getParentOf(targetNode)!!
-            targetIndexInParent = getIndexOfChild(targetNodeParent, targetNode)
+            targetIndexInParent = targetNodeParent.children.indexOf(targetNode)
         }
 
         removeNode(nodeToMove)
         insertNode(targetNodeParent, nodeToMove, targetIndexInParent)
-        expandAndSelect(nodeToMove)
     }
 
     /**
      * Returns `true` if and only if the node at row [oldIndex] can be moved to row [newIndex].
-     *
-     * Indices are looked up using [rowToNode], and are typically relative to the current expansion state of the view.
      */
     override fun canExchangeRows(oldIndex: Int, newIndex: Int): Boolean {
-        val oldNode = rowToNode(oldIndex)
-        val newNode = rowToNode(newIndex)
+        val oldNode = root.descendants.getOrNull(oldIndex)
+        val newNode = root.descendants.getOrNull(newIndex)
 
         return oldNode != null && newNode != null &&
             if (oldNode.state is Template) newNode.state is Template
@@ -155,11 +158,14 @@ class TemplateJTreeModel(list: TemplateList = TemplateList(mutableListOf())) : T
 
     /**
      * Returns `true` if and only if [node] does not have children.
+     *
+     * Throws an exception if [node] is not a [StateNode] or if [node] is not contained in this model.
      */
-    override fun isLeaf(node: Any?): Boolean {
+    override fun isLeaf(node: Any): Boolean {
         require(node is StateNode) {
-            Bundle("template_list.error.must_be_state_node", "node", node?.let { it::class.java.canonicalName })
+            Bundle("template_list.error.unknown_node_type", "node", node.javaClass.canonicalName)
         }
+        require(node in nodes) { Bundle("template_list.error.node_not_in_tree") }
 
         return !node.canHaveChildren || node.children.isEmpty()
     }
@@ -167,45 +173,41 @@ class TemplateJTreeModel(list: TemplateList = TemplateList(mutableListOf())) : T
     /**
      * Returns the [index]th child of [parent].
      *
-     * Throws an exception if [parent] has no [index]th child.
+     * Throws an exception if [parent] is not a [StateNode], if [parent] is not contained in this model, if [parent]
+     * cannot have children, or if [parent] has no [index]th child.
      */
-    override fun getChild(parent: Any?, index: Int): StateNode {
+    override fun getChild(parent: Any, index: Int): StateNode {
         require(parent is StateNode) {
-            Bundle("template_list.error.must_be_state_node", "parent", parent?.let { it::class.java.canonicalName })
+            Bundle("template_list.error.unknown_node_type", "parent", parent.javaClass.canonicalName)
         }
-        require(parent.canHaveChildren) { Bundle("template_list.error.child_of_infertile_parent") }
+        require(parent in nodes) { Bundle("template_list.error.node_not_in_tree") }
 
         return parent.children[index]
     }
 
     /**
      * Returns the number of children of [parent].
+     *
+     * Throws an exception if [parent] is not a [StateNode] or if [parent] is not contained in this model.
      */
-    override fun getChildCount(parent: Any?): Int {
+    override fun getChildCount(parent: Any): Int {
         require(parent is StateNode) {
-            Bundle("template_list.error.must_be_state_node", "parent", parent?.let { it::class.java.canonicalName })
+            Bundle("template_list.error.unknown_node_type", "parent", parent.javaClass.canonicalName)
         }
+        require(parent in nodes) { Bundle("template_list.error.node_not_in_tree") }
 
         return if (!parent.canHaveChildren) 0
         else parent.children.size
     }
 
     /**
-     * Returns the relative index of [child] in [parent], or `-1` if either [parent] or [child] is `null`, or `-1` if
-     * [child] is not a child of [parent].
+     * Returns the relative index of [child] in [parent], or `-1` if (1) either [parent] or [child] is `null`,
+     * (2) either [parent] or [child] is not a [StateNode], (3) either [parent] or [child] is not contained in this
+     * model, or (4) if [child] is not a child of [parent].
      */
-    override fun getIndexOfChild(parent: Any?, child: Any?): Int {
-        if (parent == null || child == null) return -1
-
-        require(parent is StateNode) {
-            Bundle("template_list.error.must_be_state_node", "parent", parent::class.java.canonicalName)
-        }
-        require(child is StateNode) {
-            Bundle("template_list.error.must_be_state_node", "child", child::class.java.canonicalName)
-        }
-
-        return parent.children.indexOf(child)
-    }
+    override fun getIndexOfChild(parent: Any?, child: Any?): Int =
+        if (parent !is StateNode || child !is StateNode) -1
+        else parent.children.indexOf(child)
 
     /**
      * Returns the parent of [node], or `null` if [node] has no parent.
@@ -213,7 +215,7 @@ class TemplateJTreeModel(list: TemplateList = TemplateList(mutableListOf())) : T
      * Throws an exception if [node] is not contained in this model.
      */
     fun getParentOf(node: StateNode): StateNode? {
-        require(root.contains(node)) { Bundle("template_list.error.parent_of_node_not_in_model") }
+        require(node in nodes) { Bundle("template_list.error.node_not_in_tree") }
 
         return when (node.state) {
             is TemplateList -> null
@@ -228,7 +230,7 @@ class TemplateJTreeModel(list: TemplateList = TemplateList(mutableListOf())) : T
      * Throws an exception if [node] is not contained in this model.
      */
     fun getPathToRoot(node: StateNode): TreePath {
-        require(root.contains(node)) { Bundle("template_list.error.path_of_node_not_in_model") }
+        require(node in nodes) { Bundle("template_list.error.node_not_in_tree") }
 
         return when (node.state) {
             is TemplateList -> TreePath(arrayOf(node))
@@ -238,50 +240,6 @@ class TemplateJTreeModel(list: TemplateList = TemplateList(mutableListOf())) : T
     }
 
 
-    /**
-     * Inserts [child] as the [index]th child of [parent].
-     *
-     * Throws an exception if [index] is out of bounds in [parent], i.e. if [index] is negative or there is no
-     * ([index] - 1)th child.
-     */
-    fun insertNode(parent: StateNode, child: StateNode, index: Int = getChildCount(parent)) {
-        parent.children = parent.children.toMutableList().also { it.add(index, child) }
-
-        if (parent == root && parent.children.size == 1)
-            fireNodeStructureChanged(root)
-        else
-            fireNodeInserted(child, parent, index)
-    }
-
-    /**
-     * Inserts [child] as a child into [parent] right after [after].
-     *
-     * Throws an exception if [after] is not a child of [parent].
-     */
-    fun insertNodeAfter(parent: StateNode, child: StateNode, after: StateNode) {
-        val afterIndex = getIndexOfChild(parent, after)
-        require(afterIndex >= 0) { Bundle("template_list.error.find_node_insert_parent") }
-
-        insertNode(parent, child, afterIndex + 1)
-    }
-
-    /**
-     * Removes [node] from this model.
-     *
-     * Throws an exception if [node] is not contained in this model, or if [node] is [getRoot].
-     */
-    fun removeNode(node: StateNode) {
-        require(root.contains(node)) { Bundle("template_list.error.remove_node_not_in_model") }
-        require(node != root) { Bundle("template_list.error.remove_root") }
-
-        val parent = getParentOf(node)!!
-        val oldIndex = getIndexOfChild(parent, node)
-
-        parent.children = parent.children.toMutableList().also { it.remove(node) }
-        fireNodeRemoved(node, parent, oldIndex)
-    }
-
-
     /**
      * Informs listeners that [node] has been changed.
      *
@@ -295,11 +253,11 @@ class TemplateJTreeModel(list: TemplateList = TemplateList(mutableListOf())) : T
         if (node == null) return
 
         val event =
-            if (node.state is TemplateList) {
+            if (node == root) {
                 TreeModelEvent(this, getPathToRoot(node))
             } else {
                 val parent = getParentOf(node)!!
-                TreeModelEvent(this, getPathToRoot(parent), intArrayOf(getIndexOfChild(parent, node)), arrayOf(node))
+                TreeModelEvent(this, getPathToRoot(parent), intArrayOf(parent.children.indexOf(node)), arrayOf(node))
             }
 
         treeModelListeners.forEach { it.treeNodesChanged(event) }
@@ -312,7 +270,7 @@ class TemplateJTreeModel(list: TemplateList = TemplateList(mutableListOf())) : T
      */
     fun fireNodeInserted(node: StateNode?, parent: StateNode, index: Int) {
         if (node == null) return
-        require(node.state !is TemplateList) { Bundle("template_list.error.insert_list") }
+        require(node.state !is TemplateList) { Bundle("template_list.error.cannot_insert_root") }
 
         treeModelListeners.forEach {
             it.treeNodesInserted(TreeModelEvent(this, getPathToRoot(parent), intArrayOf(index), arrayOf(node)))
@@ -329,7 +287,7 @@ class TemplateJTreeModel(list: TemplateList = TemplateList(mutableListOf())) : T
      */
     fun fireNodeRemoved(child: StateNode?, parent: StateNode, index: Int) {
         if (child == null) return
-        require(child.state !is TemplateList) { Bundle("template_list.error.remove_list") }
+        require(child.state !is TemplateList) { Bundle("template_list.error.cannot_remove_root") }
 
         treeModelListeners.forEach {
             it.treeNodesRemoved(TreeModelEvent(this, getPathToRoot(parent), intArrayOf(index), arrayOf(child)))
@@ -338,12 +296,8 @@ class TemplateJTreeModel(list: TemplateList = TemplateList(mutableListOf())) : T
 
     /**
      * Informs listeners that [node]'s structure has been changed.
-     *
-     * Does nothing if [node] is `null`.
      */
-    fun fireNodeStructureChanged(node: StateNode?) {
-        if (node == null) return
-
+    fun fireNodeStructureChanged(node: StateNode = root) {
         treeModelListeners.forEach { it.treeStructureChanged(TreeModelEvent(this, getPathToRoot(node))) }
     }
 
@@ -354,8 +308,7 @@ class TemplateJTreeModel(list: TemplateList = TemplateList(mutableListOf())) : T
      * @throws UnsupportedOperationException always
      */
     @Throws(UnsupportedOperationException::class)
-    override fun valueForPathChanged(path: TreePath, newValue: Any) =
-        throw UnsupportedOperationException(Bundle("template_list.error.change_value_by_path"))
+    override fun valueForPathChanged(path: TreePath, newValue: Any) = throw UnsupportedOperationException()
 
     /**
      * Adds [listener] as a listener.
@@ -373,12 +326,11 @@ class TemplateJTreeModel(list: TemplateList = TemplateList(mutableListOf())) : T
 }
 
 /**
- * Wraps around a state and equals another node if the contained states' UUIDs are the same.
+ * Represents a [State] in a [TemplateJTreeModel].
  *
- * A [JTree] cannot contain two objects that equal each other. However, two [State]s can equal each other even if
- * their UUIDs are different because of how equals is generated for data classes. This makes it impossible to use
- * [State]s in a [JTree]. Therefore, this node class "replaces" the equals of the contained [State] for the tree,
- * allowing it to contain two nodes that equal each other as long as their UUIDs are different.
+ * By default, two [State]s are equal if their fields are equal, regardless of their UUID. However, this is problematic
+ * for [JTree]s because a [JTree] cannot contain multiple objects that equal each other. The [StateNode] class thus
+ * "replaces" the equals of the contained [State] within the context of the [JTree].
  *
  * @property state The state contained in this node.
  * @see TemplateJTreeModel
@@ -393,44 +345,51 @@ class StateNode(val state: State) {
     /**
      * The child nodes contained in this node.
      *
-     * The getter and setter throw an exception if this node cannot contain children. An exception is thrown if and
-     * only if [canHaveChildren] is `false`.
+     * An exception is thrown if this node cannot have children.
      */
     var children: List<StateNode>
-        get() =
-            when (state) {
+        get() {
+            return when (state) {
                 is TemplateList -> state.templates.map { StateNode(it) }
                 is Template -> state.schemes.map { StateNode(it) }
-                else -> error(Bundle("template_list.error.unknown_state_type", "parent", state.javaClass.canonicalName))
+                else -> error(Bundle("template_list.error.infertile_parent"))
             }
+        }
         set(value) {
             when (state) {
                 is TemplateList -> state.templates.setAll(value.map { it.state as Template })
                 is Template -> state.schemes.setAll(value.map { it.state as Scheme })
-                else -> error(Bundle("template_list.error.unknown_state_type", "parent", state.javaClass.canonicalName))
+                else -> error(Bundle("template_list.error.infertile_parent"))
             }
         }
 
     /**
-     * The recursive children of this node in depth-first order, excluding itself.
-     *
-     * Returns an empty list if [canHaveChildren] is `false`.
+     * The (recursive) descendants of this node in depth-first order (excluding `this` node itself), or an empty list
+     * if this node cannot have children.
      */
-    val recursiveChildren: List<StateNode>
-        get() =
-            if (!canHaveChildren) emptyList()
-            else children.flatMap { listOf(it) + it.recursiveChildren }
+    val descendants: List<StateNode>
+        get() {
+            return when (state) {
+                is TemplateList -> children.flatMap { listOf(it) + it.children }
+                is Template -> children
+                else -> emptyList()
+            }
+        }
 
 
     /**
-     * Returns `true` if and only if [node] is contained in the tree rooted at this node.
+     * Returns `true` if and only if this node can have [child] as a child.
      */
-    fun contains(node: StateNode): Boolean =
-        this == node || canHaveChildren && children.any { it.contains(node) }
+    fun canHaveChild(child: StateNode) =
+        when (state) {
+            is TemplateList -> child.state is Template
+            is Template -> child.state is Scheme && child.state !is Template
+            else -> false
+        }
 
 
     /**
-     * Returns `true` if and only if [other]'s UUID is the same as [state]'s UUID.
+     * Returns `true` if and only if the UUIDs of `this`' [state] and [other]'s [state] are equal.
      */
     override fun equals(other: Any?) = other is StateNode && this.state.uuid == other.state.uuid
 
diff --git a/src/main/kotlin/com/fwdekker/randomness/template/TemplateList.kt b/src/main/kotlin/com/fwdekker/randomness/template/TemplateList.kt
index 97d02b85b..70bafb533 100644
--- a/src/main/kotlin/com/fwdekker/randomness/template/TemplateList.kt
+++ b/src/main/kotlin/com/fwdekker/randomness/template/TemplateList.kt
@@ -14,7 +14,7 @@ import com.fwdekker.randomness.string.StringScheme
 import com.fwdekker.randomness.uuid.UuidScheme
 import com.fwdekker.randomness.word.DefaultWordList
 import com.fwdekker.randomness.word.WordScheme
-import com.intellij.util.xmlb.annotations.MapAnnotation
+import com.intellij.util.xmlb.annotations.OptionTag
 
 
 /**
@@ -23,7 +23,7 @@ import com.intellij.util.xmlb.annotations.MapAnnotation
  * @property templates The collection of templates, each with a unique name.
  */
 data class TemplateList(
-    @MapAnnotation(sortBeforeSave = false)
+    @OptionTag
     val templates: MutableList<Template> = DEFAULT_TEMPLATES,
 ) : State() {
     override fun applyContext(context: Box<Settings>) {
@@ -56,6 +56,11 @@ data class TemplateList(
         }
     }
 
+    /**
+     * Note that the [context] must be updated manually.
+     *
+     * @see State.deepCopy
+     */
     override fun deepCopy(retainUuid: Boolean) =
         copy(templates = templates.map { it.deepCopy(retainUuid) }.toMutableList()).deepCopyTransient(retainUuid)
 
diff --git a/src/main/kotlin/com/fwdekker/randomness/template/TemplateListConfigurable.kt b/src/main/kotlin/com/fwdekker/randomness/template/TemplateListConfigurable.kt
index dcb377f37..72c18e0f0 100644
--- a/src/main/kotlin/com/fwdekker/randomness/template/TemplateListConfigurable.kt
+++ b/src/main/kotlin/com/fwdekker/randomness/template/TemplateListConfigurable.kt
@@ -1,8 +1,10 @@
 package com.fwdekker.randomness.template
 
 import com.fwdekker.randomness.Bundle
+import com.intellij.openapi.Disposable
 import com.intellij.openapi.options.Configurable
 import com.intellij.openapi.options.ConfigurationException
+import com.intellij.openapi.util.Disposer
 import javax.swing.JComponent
 
 
@@ -18,7 +20,7 @@ import javax.swing.JComponent
  *
  * @see TemplateSettingsAction
  */
-class TemplateListConfigurable : Configurable {
+class TemplateListConfigurable : Configurable, Disposable {
     /**
      * The user interface for changing the settings, displayed in IntelliJ's settings window.
      */
@@ -37,7 +39,7 @@ class TemplateListConfigurable : Configurable {
     override fun isModified() = editor.isModified() || editor.doValidate() != null
 
     /**
-     * Saves the changes in the settings component to the default settings object.
+     * Saves the changes in the settings component to the default settings object, and updates template shortcuts.
      *
      * @throws ConfigurationException if the changes cannot be saved
      */
@@ -47,7 +49,11 @@ class TemplateListConfigurable : Configurable {
         if (validationInfo != null)
             throw ConfigurationException(validationInfo, Bundle("template_list.error.failed_to_save_settings"))
 
+        val oldList = editor.originalTemplateList.deepCopy(retainUuid = true)
         editor.apply()
+        val newList = editor.originalTemplateList.deepCopy(retainUuid = true)
+
+        TemplateActionLoader().updateActions(oldList.templates, newList.templates)
     }
 
     /**
@@ -56,18 +62,21 @@ class TemplateListConfigurable : Configurable {
     override fun reset() = editor.reset()
 
     /**
-     * Disposes the configurable's resources.
+     * Recursively disposes this configurable's resources.
      */
-    override fun disposeUIResources() {
-        editor.dispose()
-    }
+    override fun disposeUIResources() = Disposer.dispose(this)
+
+    /**
+     * Non-recursively disposes this configurable's resources.
+     */
+    override fun dispose() = Unit
 
 
     /**
      * Creates a new editor and returns the root pane of the created editor.
      */
     override fun createComponent(): JComponent {
-        editor = TemplateListEditor()
+        editor = TemplateListEditor().also { Disposer.register(this, it) }
         editor.queueSelection = templateToSelect
         return editor.rootComponent
     }
diff --git a/src/main/kotlin/com/fwdekker/randomness/template/TemplateListEditor.kt b/src/main/kotlin/com/fwdekker/randomness/template/TemplateListEditor.kt
index 73fbc295e..cf0036133 100644
--- a/src/main/kotlin/com/fwdekker/randomness/template/TemplateListEditor.kt
+++ b/src/main/kotlin/com/fwdekker/randomness/template/TemplateListEditor.kt
@@ -10,6 +10,7 @@ import com.fwdekker.randomness.decimal.DecimalScheme
 import com.fwdekker.randomness.decimal.DecimalSchemeEditor
 import com.fwdekker.randomness.integer.IntegerScheme
 import com.fwdekker.randomness.integer.IntegerSchemeEditor
+import com.fwdekker.randomness.setAll
 import com.fwdekker.randomness.string.StringScheme
 import com.fwdekker.randomness.string.StringSchemeEditor
 import com.fwdekker.randomness.ui.PreviewPanel
@@ -20,12 +21,15 @@ import com.fwdekker.randomness.word.WordScheme
 import com.fwdekker.randomness.word.WordSchemeEditor
 import com.intellij.openapi.Disposable
 import com.intellij.openapi.ui.Splitter
+import com.intellij.openapi.util.Disposer
 import com.intellij.ui.OnePixelSplitter
 import com.intellij.ui.components.JBScrollPane
 import com.intellij.util.ui.JBEmptyBorder
 import java.awt.BorderLayout
 import java.awt.Dimension
 import java.awt.KeyboardFocusManager
+import java.beans.PropertyChangeEvent
+import java.beans.PropertyChangeListener
 import javax.swing.JComponent
 import javax.swing.JPanel
 import javax.swing.SwingUtilities
@@ -37,22 +41,22 @@ import javax.swing.SwingUtilities
  * The editor essentially has a master-detail layout. On the left, a [TemplateJTree] shows all templates and the schemes
  * contained within them, and on the right, a [SchemeEditor] for the currently-selected template or scheme is shown.
  *
- * Though this editor only changes [TemplateList]s, it still maintains a reference to
- *
- * @property originalSettings The settings containing the templates to edit.
+ * @property originalTemplateList The templates to edit.
  * @see TemplateListConfigurable
  */
-class TemplateListEditor(private val originalSettings: Settings = Settings.DEFAULT) : Disposable {
+class TemplateListEditor(val originalTemplateList: TemplateList = Settings.DEFAULT.templateList) : Disposable {
     /**
      * The root component of the editor.
      */
     val rootComponent = JPanel(BorderLayout())
 
-    private val currentSettings = Settings()
-    private val templateTree = TemplateJTree(originalSettings, currentSettings)
+    private val currentTemplateList = TemplateList() // Synced with [originalTemplateList] in [reset]
+    private val templateTree = TemplateJTree(originalTemplateList, currentTemplateList)
     private val schemeEditorPanel = JPanel(BorderLayout())
     private var schemeEditor: SchemeEditor<*>? = null
-    private val previewPanel: PreviewPanel
+    private val previewPanel =
+        PreviewPanel { templateTree.selectedTemplate ?: StringScheme("") }
+            .also { Disposer.register(this, it) }
 
     /**
      * The UUID of the scheme to select after the next invocation of [reset].
@@ -71,13 +75,6 @@ class TemplateListEditor(private val originalSettings: Settings = Settings.DEFAU
         splitter.firstComponent = templateTree.asDecoratedPanel()
 
         // Right half
-        previewPanel = PreviewPanel {
-            val selectedNode = templateTree.selectedNodeNotRoot ?: return@PreviewPanel StringScheme("")
-            val parentNode = templateTree.myModel.getParentOf(selectedNode)!!
-
-            if (selectedNode.state is Template) selectedNode.state
-            else parentNode.state as Template
-        }
         addChangeListenerTo(templateTree) { previewPanel.updatePreview() }
         schemeEditorPanel.border = JBEmptyBorder(EDITOR_PANEL_MARGIN)
         schemeEditorPanel.add(previewPanel.rootComponent, BorderLayout.SOUTH)
@@ -86,31 +83,31 @@ class TemplateListEditor(private val originalSettings: Settings = Settings.DEFAU
 
         // Load current state
         reset()
+        templateTree.expandNodes()
     }
 
     /**
      * Invoked when an entry is (de)selected in the tree.
      */
     private fun onTreeSelection() {
+        // Remove old editor
         schemeEditor?.also { editor ->
             schemeEditorPanel.remove((schemeEditorPanel.layout as BorderLayout).getLayoutComponent(BorderLayout.CENTER))
-            editor.dispose()
             schemeEditor = null
-        }
-
-        val selectedNode = templateTree.selectedNodeNotRoot
-        val selectedState = selectedNode?.state
-        if (selectedState !is Scheme) {
             schemeEditorPanel.revalidate() // Hide editor immediately
-            return
+
+            Disposer.dispose(editor)
         }
 
+        // Create new editor
+        val selectedState = templateTree.selectedScheme ?: return
         schemeEditor = createEditor(selectedState)
             .also { editor ->
                 editor.addChangeListener {
                     editor.apply()
-                    templateTree.myModel.fireNodeStructureChanged(selectedNode)
+                    templateTree.reload(selectedState)
                 }
+                editor.apply() // Apply validation fixes from UI
 
                 schemeEditorPanel.add(
                     JBScrollPane(editor.rootComponent).also {
@@ -119,24 +116,13 @@ class TemplateListEditor(private val originalSettings: Settings = Settings.DEFAU
                     },
                     BorderLayout.CENTER
                 )
-                KeyboardFocusManager.getCurrentKeyboardFocusManager().addPropertyChangeListener("focusOwner") {
-                    val focused = it.newValue as? JComponent
-                    if (focused == null || !editor.rootComponent.isAncestorOf(focused))
-                        return@addPropertyChangeListener
-
-                    editor.rootComponent.scrollRectToVisible(
-                        SwingUtilities.convertRectangle(
-                            focused,
-                            focused.bounds,
-                            editor.rootComponent
-                        )
-                    )
-                }
 
-                editor.apply() // Apply validation fixes from UI
-                templateTree.myModel.fireNodeStructureChanged(selectedNode)
-                schemeEditorPanel.revalidate() // Show editor immediately
+                ScrollOnFocusListener(KeyboardFocusManager.getCurrentKeyboardFocusManager(), editor).install()
             }
+
+        // Show new editor
+        templateTree.reload(selectedState)
+        schemeEditorPanel.revalidate() // Show editor immediately
     }
 
     /**
@@ -152,8 +138,8 @@ class TemplateListEditor(private val originalSettings: Settings = Settings.DEFAU
             is DateTimeScheme -> DateTimeSchemeEditor(scheme)
             is TemplateReference -> TemplateReferenceEditor(scheme)
             is Template -> TemplateEditor(scheme)
-            else -> error(Bundle("template_list.error.unknown_state_type", "scheme", scheme.javaClass.canonicalName))
-        }
+            else -> error(Bundle("template_list.error.unknown_scheme_type", scheme.javaClass.canonicalName))
+        }.also { Disposer.register(this, it) }
 
 
     /**
@@ -161,24 +147,21 @@ class TemplateListEditor(private val originalSettings: Settings = Settings.DEFAU
      *
      * @return `null` if the state is valid, or a string explaining why the state is invalid
      */
-    fun doValidate(): String? = currentSettings.doValidate()
+    fun doValidate(): String? = currentTemplateList.doValidate()
 
     /**
      * Returns `true` if and only if the editor contains modifications relative to the last saved state.
      */
-    fun isModified() = originalSettings != currentSettings
+    fun isModified() = originalTemplateList != currentTemplateList
 
     /**
-     * Saves the editor's state into [originalSettings].
+     * Saves the editor's state into [originalTemplateList].
      *
      * Does nothing if and only if [isModified] returns `false`.
      */
     fun apply() {
-        val oldList = originalSettings.templates
-        originalSettings.copyFrom(currentSettings)
-        val newList = originalSettings.templates
-
-        TemplateActionLoader().updateActions(oldList, newList)
+        originalTemplateList.templates.setAll(currentTemplateList.deepCopy(retainUuid = true).templates)
+        originalTemplateList.applyContext((+originalTemplateList.context).copy(templateList = originalTemplateList))
     }
 
     /**
@@ -187,11 +170,13 @@ class TemplateListEditor(private val originalSettings: Settings = Settings.DEFAU
      * Does nothing if and only if [isModified] return `false`.
      */
     fun reset() {
-        currentSettings.copyFrom(originalSettings)
+        currentTemplateList.templates.setAll(originalTemplateList.deepCopy(retainUuid = true).templates)
+        currentTemplateList.applyContext((+currentTemplateList.context).copy(templateList = currentTemplateList))
+
         templateTree.reload()
 
         queueSelection?.also {
-            templateTree.selectedScheme = currentSettings.templateList.getSchemeByUuid(it)
+            templateTree.selectedScheme = currentTemplateList.getSchemeByUuid(it)
             SwingUtilities.invokeLater { schemeEditor?.preferredFocusedComponent?.requestFocus() }
 
             queueSelection = null
@@ -201,9 +186,42 @@ class TemplateListEditor(private val originalSettings: Settings = Settings.DEFAU
     /**
      * Disposes this editor's resources.
      */
-    override fun dispose() {
-        schemeEditor?.dispose()
-        previewPanel.dispose()
+    override fun dispose() = Unit
+
+
+    /**
+     * Scrolls to the focused element within the [editor], registering this listener with the [focusManager], and
+     * automatically disposing itself when the [editor] is disposed.
+     */
+    private class ScrollOnFocusListener<S : Scheme>(
+        private val focusManager: KeyboardFocusManager,
+        private val editor: SchemeEditor<S>,
+    ) : PropertyChangeListener, Disposable {
+        /**
+         * Scrolls to the newly focused element if that element is in the [editor].
+         */
+        override fun propertyChange(event: PropertyChangeEvent?) {
+            val focused = event?.newValue as? JComponent
+            if (focused == null || !editor.rootComponent.isAncestorOf(focused))
+                return
+
+            val target = SwingUtilities.convertRectangle(focused, focused.bounds, editor.rootComponent)
+            editor.rootComponent.scrollRectToVisible(target)
+        }
+
+
+        /**
+         * Installs this listener with the [focusManager].
+         */
+        fun install() {
+            Disposer.register(editor, this)
+            focusManager.addPropertyChangeListener("focusOwner", this)
+        }
+
+        /**
+         * Removes this listener from the [focusManager].
+         */
+        override fun dispose() = focusManager.removePropertyChangeListener("focusOwner", this)
     }
 
 
diff --git a/src/main/kotlin/com/fwdekker/randomness/template/TemplateReference.kt b/src/main/kotlin/com/fwdekker/randomness/template/TemplateReference.kt
index d75a195d7..a0c92d51a 100644
--- a/src/main/kotlin/com/fwdekker/randomness/template/TemplateReference.kt
+++ b/src/main/kotlin/com/fwdekker/randomness/template/TemplateReference.kt
@@ -98,6 +98,11 @@ data class TemplateReference(
         }
     }
 
+    /**
+     * Note that the [context] must be updated manually.
+     *
+     * @see Scheme.deepCopy
+     */
     override fun deepCopy(retainUuid: Boolean) =
         copy(arrayDecorator = arrayDecorator.deepCopy(retainUuid)).deepCopyTransient(retainUuid)
 
diff --git a/src/main/kotlin/com/fwdekker/randomness/ui/PreviewPanel.kt b/src/main/kotlin/com/fwdekker/randomness/ui/PreviewPanel.kt
index 322a58583..b46d3ea8d 100644
--- a/src/main/kotlin/com/fwdekker/randomness/ui/PreviewPanel.kt
+++ b/src/main/kotlin/com/fwdekker/randomness/ui/PreviewPanel.kt
@@ -27,8 +27,6 @@ import kotlin.random.Random
  * changes. After registering some components with this panel, the preview will be updated whenever those components are
  * updated.
  *
- * Note that [dispose] should be invoked when this panel is no longer used.
- *
  * @property getScheme Returns a scheme that generates previews. Its random source will be changed.
  */
 @Suppress("detekt:LateinitUsage") // Initialized in panel DSL
@@ -80,7 +78,7 @@ class PreviewPanel(private val getScheme: () -> Scheme) : Disposable {
     /**
      * Disposes this panel's resources, to be used when this panel is no longer used.
      */
-    override fun dispose() = Disposer.dispose(this)
+    override fun dispose() = Unit
 
 
     /**
diff --git a/src/main/kotlin/com/fwdekker/randomness/word/WordSchemeEditor.kt b/src/main/kotlin/com/fwdekker/randomness/word/WordSchemeEditor.kt
index 2cf3f42ba..5f4d6aa35 100644
--- a/src/main/kotlin/com/fwdekker/randomness/word/WordSchemeEditor.kt
+++ b/src/main/kotlin/com/fwdekker/randomness/word/WordSchemeEditor.kt
@@ -13,11 +13,13 @@ import com.fwdekker.randomness.ui.withName
 import com.fwdekker.randomness.ui.withSimpleRenderer
 import com.fwdekker.randomness.word.WordScheme.Companion.PRESET_AFFIX_DECORATOR_DESCRIPTORS
 import com.fwdekker.randomness.word.WordScheme.Companion.PRESET_CAPITALIZATION
+import com.intellij.openapi.Disposable
 import com.intellij.openapi.application.runWriteAction
 import com.intellij.openapi.command.impl.UndoManagerImpl
 import com.intellij.openapi.command.undo.DocumentReferenceManager
 import com.intellij.openapi.command.undo.UndoManager
 import com.intellij.openapi.editor.Document
+import com.intellij.openapi.editor.Editor
 import com.intellij.openapi.editor.EditorFactory
 import com.intellij.openapi.ui.ComboBox
 import com.intellij.openapi.util.Disposer
@@ -70,7 +72,7 @@ class WordSchemeEditor(scheme: WordScheme = WordScheme()) : SchemeEditor<WordSch
                 extraComponents += document
 
                 val wordListEditor = factory.createEditor(document)
-                Disposer.register(this@WordSchemeEditor) { EditorFactory.getInstance().releaseEditor(wordListEditor) }
+                Disposer.register(this@WordSchemeEditor, factory.wrapDisposable(wordListEditor))
                 cell(wordListEditor.component)
                     .onReset { document.resetUndoHistory() }
                     .horizontalAlign(HorizontalAlign.FILL)
@@ -141,3 +143,12 @@ fun Document.getWordList() = this.text.split('\n').filterNot { it.isBlank() }
  */
 fun Document.setWordList(wordList: List<String>) =
     runWriteAction { setText(wordList.joinToString(separator = "\n", postfix = "\n")) }
+
+/**
+ * Returns a [Disposable] that can dispose the [editor] through the [EditorFactory] that created it.
+ */
+@Suppress("ObjectLiteralToLambda") // `Disposable` docs state that lambdas should be avoided
+private fun EditorFactory.wrapDisposable(editor: Editor) =
+    object : Disposable {
+        override fun dispose() = this@wrapDisposable.releaseEditor(editor)
+    }
diff --git a/src/main/resources/randomness.properties b/src/main/resources/randomness.properties
index 6d1242243..08fbd971a 100644
--- a/src/main/resources/randomness.properties
+++ b/src/main/resources/randomness.properties
@@ -121,22 +121,17 @@ template.name.settings_suffix=%1$s Settings
 template.name.unknown=<unknown>
 template.ui.name_option=&Name:
 template.title=Template
-template_list.error.add_empty_row=Cannot add empty row.
-template_list.error.add_template_to_non_root=Cannot add non-template to root.
-template_list.error.change_value_by_path=Cannot change value by path.
-template_list.error.child_of_infertile_parent=Cannot get child of parent that cannot have children.
+template_list.error.cannot_insert_root='TemplateList' cannot have parent so cannot be inserted.
+template_list.error.cannot_remove_root=Cannot remove root from model.
+template_list.error.cannot_swap_rows=Cannot swap row at index %1$d with row at index %2$d.
 template_list.error.duplicate_name=Template names should be unique. Rename template '%1$s'.
 template_list.error.failed_to_save_settings=Failed To Save Settings
-template_list.error.find_node_insert_parent=Cannot find node to insert after in parent.
-template_list.error.insert_list=Template list cannot have parent so cannot be inserted.
-template_list.error.must_be_state_node=%1$S must be a 'StateNode', but was a '%2$s'.
-template_list.error.parent_of_node_not_in_model=Cannot get parent of node not in this model.
-template_list.error.path_of_node_not_in_model=Cannot get path of node not in this model.
-template_list.error.remove_list=Template list cannot have parent so cannot be removed.
-template_list.error.remove_node_not_in_model=Cannot remove node not contained in this model.
-template_list.error.remove_root=Cannot remove root from model.
-template_list.error.remove_row_by_index=Cannot remove row by index.
-template_list.error.unknown_state_type=Unknown %1$s type '%2$s'.
+template_list.error.infertile_parent=Cannot access child of parent that cannot have children.
+template_list.error.node_not_in_tree=Node is not in this tree.
+template_list.error.unknown_node_type=Unknown node type '%2$s'.
+template_list.error.unknown_scheme_type=Unknown scheme type '%1$s'.
+template_list.error.wrong_child_type=Parent cannot accept node to insert.
+template_list.error.wrong_parent=Node to insert after is not child of given parent.
 template_list.ui.empty=No templates configured.
 uuid.title=UUID
 uuid.add_dashes=&Add dashes
diff --git a/src/test/kotlin/com/fwdekker/randomness/SettingsTest.kt b/src/test/kotlin/com/fwdekker/randomness/SettingsTest.kt
index a98771cd0..84e81cd4d 100644
--- a/src/test/kotlin/com/fwdekker/randomness/SettingsTest.kt
+++ b/src/test/kotlin/com/fwdekker/randomness/SettingsTest.kt
@@ -2,14 +2,12 @@ package com.fwdekker.randomness
 
 import com.fwdekker.randomness.template.Template
 import com.fwdekker.randomness.template.TemplateList
-import com.fwdekker.randomness.testhelpers.DummyState
+import com.fwdekker.randomness.template.TemplateReference
 import com.fwdekker.randomness.testhelpers.shouldValidateAsBundle
-import io.kotest.assertions.throwables.shouldThrow
 import io.kotest.core.spec.style.FunSpec
 import io.kotest.data.row
 import io.kotest.datatest.withData
 import io.kotest.matchers.shouldBe
-import io.kotest.matchers.types.shouldNotBeSameInstanceAs
 
 
 /**
@@ -43,24 +41,17 @@ object SettingsTest : FunSpec({
 
             settings.templates[0].name shouldBe "old"
         }
-    }
-
-    context("copyFrom") {
-        test("cannot copy from another type") {
-            val settings = Settings()
-
-            shouldThrow<IllegalArgumentException> { settings.copyFrom(DummyState()) }
-                .message shouldBe "Cannot copy from different type."
-        }
 
-        test("deep-copies the template list") {
-            val settings = Settings(templateList = TemplateList(mutableListOf(Template("old"))))
-            val other = Settings(templateList = TemplateList(mutableListOf(Template("new"))))
+        test("sets the copy's context to itself") {
+            val referenced = Template("old")
+            val reference = Template("ref", schemes = mutableListOf(TemplateReference(referenced.uuid)))
+            val settings = Settings(templateList = TemplateList(mutableListOf(referenced, reference)))
 
-            settings.copyFrom(other)
+            val copy = settings.deepCopy(retainUuid = true)
+            copy.templates.single { it.name == "old" }.name = "new"
 
-            settings.templateList shouldNotBeSameInstanceAs other.templateList
-            settings.templates[0].name shouldBe "new"
+            val referencingCopy = copy.templates.single { it.name == "ref" }
+            (referencingCopy.schemes.single() as TemplateReference).template?.name shouldBe "new"
         }
     }
 })
diff --git a/src/test/kotlin/com/fwdekker/randomness/StateTest.kt b/src/test/kotlin/com/fwdekker/randomness/StateTest.kt
index 9cfb60936..05febaf9a 100644
--- a/src/test/kotlin/com/fwdekker/randomness/StateTest.kt
+++ b/src/test/kotlin/com/fwdekker/randomness/StateTest.kt
@@ -3,7 +3,6 @@ package com.fwdekker.randomness
 import com.fwdekker.randomness.testhelpers.DummyState
 import io.kotest.core.NamedTag
 import io.kotest.core.spec.style.FunSpec
-import io.kotest.matchers.collections.shouldContainExactly
 import io.kotest.matchers.collections.shouldHaveSize
 import io.kotest.matchers.shouldBe
 import io.kotest.matchers.shouldNotBe
@@ -72,45 +71,4 @@ object StateTest : FunSpec({
             copy.list shouldHaveSize 1
         }
     }
-
-    context("copyFrom") {
-        test("copies the UUID") {
-            val original = DummyState()
-            val other = DummyState()
-
-            original.copyFrom(other)
-
-            original.uuid shouldBe other.uuid
-        }
-
-        test("copies fields") {
-            val original = DummyState(mutableListOf(0))
-            val other = DummyState(mutableListOf(1))
-
-            original.copyFrom(other)
-
-            original.list shouldContainExactly listOf(1)
-        }
-
-        test("deep-copies fields") {
-            val original = DummyState(mutableListOf(0))
-            val other = DummyState(mutableListOf(1))
-
-            original.copyFrom(other)
-            other.list.add(2)
-
-            original.list shouldContainExactly listOf(1)
-        }
-
-        test("copies the context") {
-            val context = Settings()
-            val original = DummyState()
-            val other = DummyState()
-            other.applyContext(context)
-
-            original.copyFrom(other)
-
-            +original.context shouldBeSameInstanceAs context
-        }
-    }
 })
diff --git a/src/test/kotlin/com/fwdekker/randomness/template/TemplateJTreeModelTest.kt b/src/test/kotlin/com/fwdekker/randomness/template/TemplateJTreeModelTest.kt
index 1e9a8bba6..5105fd89e 100644
--- a/src/test/kotlin/com/fwdekker/randomness/template/TemplateJTreeModelTest.kt
+++ b/src/test/kotlin/com/fwdekker/randomness/template/TemplateJTreeModelTest.kt
@@ -1,7 +1,6 @@
 package com.fwdekker.randomness.template
 
 import com.fwdekker.randomness.Scheme
-import com.fwdekker.randomness.State
 import com.fwdekker.randomness.testhelpers.DummyScheme
 import com.fwdekker.randomness.testhelpers.beEmptyIntArray
 import com.fwdekker.randomness.testhelpers.beforeNonContainer
@@ -22,7 +21,6 @@ import io.kotest.matchers.nulls.beNull
 import io.kotest.matchers.should
 import io.kotest.matchers.shouldBe
 import io.kotest.matchers.shouldNotBe
-import io.kotest.matchers.types.shouldBeSameInstanceAs
 import javax.swing.event.TreeModelEvent
 import javax.swing.event.TreeModelListener
 
@@ -31,129 +29,231 @@ import javax.swing.event.TreeModelListener
  * Unit tests for [TemplateJTreeModel].
  */
 object TemplateJTreeModelTest : FunSpec({
+    lateinit var list: TemplateList
     lateinit var model: TemplateJTreeModel
 
     fun List<Scheme>.names() = this.map { it.name }
 
 
     beforeNonContainer {
-        model = TemplateJTreeModel(
-            TemplateList(
-                mutableListOf(
-                    Template(
-                        // row 0
-                        "Template0",
-                        mutableListOf(
-                            DummyScheme("Scheme0"), // row 1
-                            DummyScheme("Scheme1"), // row 2
-                        ),
+        list = TemplateList(
+            mutableListOf(
+                Template(
+                    "Template0", // row 0
+                    mutableListOf(
+                        DummyScheme("Scheme0"), // row 1
+                        DummyScheme("Scheme1"), // row 2
                     ),
-                    Template(
-                        // row 3
-                        "Template1",
-                        mutableListOf(DummyScheme("Scheme2")), // row 4
-                    ),
-                    Template("Template2", mutableListOf()), // row 5
-                )
+                ),
+                Template(
+                    "Template1", // row 3
+                    mutableListOf(DummyScheme("Scheme2")), // row 4
+                ),
+                Template(
+                    "Template2", // row 5
+                    mutableListOf(),
+                ),
             )
         )
+        model = TemplateJTreeModel(list)
     }
 
 
-    context("rowToNode (default implementation)") {
-        withData(
-            mapOf<String, Row2<Int, () -> StateNode?>>(
-                "negative index" to
-                    row(-2) { null },
-                "too-high index" to
-                    row(241) { null },
-                "0 is first template" to
-                    row(0) { model.root.children[0] },
-                "1 is first leaf" to
-                    row(1) { model.root.children[0].children[0] },
-                "row number for template includes siblings' schemes" to
-                    row(5) { model.root.children[2] },
-                "row number for scheme includes aunts'/uncles' schemes" to
-                    row(4) { model.root.children[1].children[0] },
-            )
-        ) { (row, node) -> model.rowToNode(row) shouldBe node() }
+    context("addRow") {
+        test("throws an error") {
+            shouldThrow<UnsupportedOperationException> { model.addRow() }
+        }
     }
 
-    context("nodeToRow (default implementation)") {
-        withData(
-            mapOf<String, Row2<() -> StateNode?, Int>>(
-                "null" to
-                    row({ null }, -1),
-                "unknown node" to
-                    row({ StateNode(DummyScheme()) }, -1),
-                "first template is 0" to
-                    row({ model.root.children[0] }, 0),
-                "first scheme is 1" to
-                    row({ model.root.children[0].children[0] }, 1),
-                "row number for template includes siblings' schemes" to
-                    row({ model.root.children[2] }, 5),
-                "row number for scheme includes aunts'/uncles' schemes" to
-                    row({ model.root.children[1].children[0] }, 4),
-            )
-        ) { (node, row) -> model.nodeToRow(node()) shouldBe row }
+    context("removeRow") {
+        test("throws an error") {
+            shouldThrow<UnsupportedOperationException> { model.removeRow(4) }
+        }
     }
 
 
-    context("reload") {
-        test("informs listeners that the root has been reloaded") {
+    context("insertNode") {
+        test("throws an error if the parent is not in the tree") {
+            val parent = StateNode(Template())
+            val child = StateNode(DummyScheme())
+
+            shouldThrow<IllegalArgumentException> { model.insertNode(parent, child) }
+                .message should matchBundle("template_list.error.node_not_in_tree")
+        }
+
+        test("throws an error if the child is not a valid child for the parent") {
+            val parent = model.root
+            val child = StateNode(DummyScheme())
+
+            shouldThrow<IllegalArgumentException> { model.insertNode(parent, child) }
+                .message should matchBundle("template_list.error.wrong_child_type")
+        }
+
+        test("throws an error when a node is inserted at a negative index") {
+            shouldThrow<IndexOutOfBoundsException> { model.insertNode(model.root, StateNode(Template()), index = -2) }
+        }
+
+        test("throws an error if a node is inserted at a too-high index") {
+            shouldThrow<IndexOutOfBoundsException> { model.insertNode(model.root, StateNode(Template()), index = 14) }
+        }
+
+
+        test("inserts a node at a specific index") {
+            val node = StateNode(Template("Template3"))
+
+            model.insertNode(model.root, node, index = 1)
+
+            model.root.children shouldHaveSize 4
+            model.root.children[1] shouldBe node
+            list.templates.names() shouldContainExactly listOf("Template0", "Template3", "Template1", "Template2")
+        }
+
+        test("inserts a node at the last index of the parent") {
+            val node = StateNode(Template("Template3"))
+
+            model.insertNode(model.root, node, index = 3)
+
+            model.root.children shouldHaveSize 4
+            model.root.children[3] shouldBe node
+            list.templates.names() shouldContainExactly listOf("Template0", "Template1", "Template2", "Template3")
+        }
+
+
+        test("informs listeners of the insertion") {
             var lastEvent: TreeModelEvent? = null
             model.addTreeModelListener(SimpleTreeModelListener { lastEvent = it })
 
-            val oldList = model.list
-            model.reload()
+            val scheme = StateNode(DummyScheme())
+            model.insertNode(model.root.children[0], scheme)
+
+            lastEvent!!.treePath.lastPathComponent shouldBe model.root.children[0]
+            lastEvent!!.childIndices shouldContainExactly arrayOf(2)
+            lastEvent!!.children shouldContainExactly arrayOf(scheme)
+        }
+
+        test("informs listeners of a node insertion if the root's not-only child was inserted") {
+            var lastEvent: TreeModelEvent? = null
+            model.addTreeModelListener(SimpleTreeModelListener { lastEvent = it })
+
+            val node = StateNode(Template("Template3"))
+            model.insertNode(model.root, node, index = 1)
 
-            model.list shouldBeSameInstanceAs oldList
             lastEvent!!.treePath.lastPathComponent shouldBe model.root
-            lastEvent!!.childIndices should beEmptyIntArray()
-            lastEvent!!.children should beNull()
+            lastEvent!!.childIndices shouldContainExactly arrayOf(1)
+            lastEvent!!.children shouldContainExactly arrayOf(node)
         }
 
-        test("informs listeners that a different root has been loaded") {
+        test("informs listeners of a structure change if the root's now-only child was inserted") {
+            list.templates.clear()
+            model.fireNodeStructureChanged()
+
             var lastEvent: TreeModelEvent? = null
             model.addTreeModelListener(SimpleTreeModelListener { lastEvent = it })
 
-            val newList = TemplateList(mutableListOf())
-            model.reload(newList)
+            val node = StateNode(Template("Template3"))
+            model.insertNode(model.root, node)
 
-            model.list shouldBeSameInstanceAs newList
-            lastEvent!!.treePath.lastPathComponent shouldBe StateNode(newList)
+            lastEvent!!.treePath.lastPathComponent shouldBe model.root
             lastEvent!!.childIndices should beEmptyIntArray()
             lastEvent!!.children should beNull()
         }
     }
 
+    context("insertNodeAfter") {
+        test("throws an error if the parent is not in the tree") {
+            val template = Template(schemes = mutableListOf(DummyScheme("after")))
 
-    context("addRow") {
-        test("throws an error") {
-            shouldThrow<UnsupportedOperationException> { model.addRow() }
-                .message should matchBundle("template_list.error.add_empty_row")
+            val parent = StateNode(template)
+            val after = StateNode(template.schemes[0])
+            val child = StateNode(DummyScheme("Child"))
+
+            shouldThrow<IllegalArgumentException> { model.insertNodeAfter(parent, after, child) }
+                .message should matchBundle("template_list.error.node_not_in_tree")
+        }
+
+        test("throws an error if the parent cannot have children") {
+            val parent = StateNode(list.templates[0].schemes[0])
+            val after = StateNode(DummyScheme())
+            val child = StateNode(DummyScheme())
+
+            shouldThrow<IllegalStateException> { model.insertNodeAfter(parent, after, child) }
+                .message should matchBundle("template_list.error.infertile_parent")
+        }
+
+        test("throws an error if the node to insert after is not in the parent") {
+            val parent = StateNode(list.templates[1])
+            val after = StateNode(list.templates[0].schemes[0])
+            val child = StateNode(DummyScheme())
+
+            shouldThrow<IllegalArgumentException> { model.insertNodeAfter(parent, after, child) }
+                .message should matchBundle("template_list.error.wrong_parent")
+        }
+
+
+        test("inserts the node after the given node") {
+            val parent = StateNode(list.templates[0])
+            val after = StateNode(list.templates[0].schemes[1])
+            val child = StateNode(DummyScheme("Child"))
+
+            model.insertNodeAfter(parent, after, child)
+
+            parent.children[2] shouldBe child
         }
     }
 
-    context("removeRow") {
-        test("throws an error") {
-            shouldThrow<UnsupportedOperationException> { model.removeRow(4) }
-                .message should matchBundle("template_list.error.remove_row_by_index")
+    context("removeNode") {
+        test("throws an error if the given node is not contained in the model") {
+            shouldThrow<IllegalArgumentException> { model.removeNode(StateNode(DummyScheme())) }
+                .message should matchBundle("template_list.error.node_not_in_tree")
+        }
+
+        test("throws an error if the given node is the root of the model") {
+            shouldThrow<IllegalArgumentException> { model.removeNode(model.root) }
+                .message should matchBundle("template_list.error.cannot_remove_root")
+        }
+
+
+        test("removes a node from the model and the underlying list") {
+            val node = model.root.children[1]
+
+            model.removeNode(node)
+
+            model.root.children shouldHaveSize 2
+            model.root.children shouldNotContain node
+            list.templates shouldHaveSize 2
+            list.templates shouldNotContain node.state
+        }
+
+        test("informs listeners of the removal") {
+            val node = model.root.children[2]
+
+            var lastEvent: TreeModelEvent? = null
+            model.addTreeModelListener(SimpleTreeModelListener { lastEvent = it })
+            model.removeNode(node)
+
+            lastEvent!!.treePath.lastPathComponent shouldBe model.root
+            lastEvent!!.childIndices shouldContainExactly arrayOf(2)
+            lastEvent!!.children shouldContainExactly arrayOf(node)
         }
     }
 
     context("exchangeRows") {
+        test("cannot swap out-of-bounds indices") {
+            shouldThrow<IllegalArgumentException> { model.exchangeRows(3, 495) }
+                .message should matchBundle("template_list.error.cannot_swap_rows")
+        }
+
         context("templates") {
             test("swaps a template with the previous template") {
                 model.exchangeRows(5, 3)
 
-                model.list.templates.names() shouldContainExactly listOf("Template0", "Template2", "Template1")
+                list.templates.names() shouldContainExactly listOf("Template0", "Template2", "Template1")
             }
 
             test("swaps a template with the next template") {
                 model.exchangeRows(0, 3)
 
-                model.list.templates.names() shouldContainExactly listOf("Template1", "Template0", "Template2")
+                list.templates.names() shouldContainExactly listOf("Template1", "Template0", "Template2")
             }
         }
 
@@ -161,27 +261,27 @@ object TemplateJTreeModelTest : FunSpec({
             test("swaps a scheme with the previous scheme under the same parent") {
                 model.exchangeRows(1, 2)
 
-                model.list.templates[0].schemes.names() shouldContainExactly listOf("Scheme1", "Scheme0")
+                list.templates[0].schemes.names() shouldContainExactly listOf("Scheme1", "Scheme0")
             }
 
             test("swaps a scheme with the next scheme under the same parent") {
                 model.exchangeRows(2, 1)
 
-                model.list.templates[0].schemes.names() shouldContainExactly listOf("Scheme1", "Scheme0")
+                list.templates[0].schemes.names() shouldContainExactly listOf("Scheme1", "Scheme0")
             }
 
             test("'swaps' a scheme with its parent, making it the last child of the parent's previous sibling") {
                 model.exchangeRows(4, 3)
 
-                model.list.templates[0].schemes.names() shouldContainExactly listOf("Scheme0", "Scheme1", "Scheme2")
-                model.list.templates[1].schemes should beEmpty()
+                list.templates[0].schemes.names() shouldContainExactly listOf("Scheme0", "Scheme1", "Scheme2")
+                list.templates[1].schemes should beEmpty()
             }
 
             test("moves a scheme to its parent's next sibling, making it that sibling's first child") {
                 model.exchangeRows(4, 5)
 
-                model.list.templates[1].schemes should beEmpty()
-                model.list.templates[2].schemes.names() shouldContainExactly listOf("Scheme2")
+                list.templates[1].schemes should beEmpty()
+                list.templates[2].schemes.names() shouldContainExactly listOf("Scheme2")
             }
         }
     }
@@ -204,27 +304,37 @@ object TemplateJTreeModelTest : FunSpec({
     context("isLeaf") {
         test("throws an error if the given node is not a StateNode") {
             shouldThrow<IllegalArgumentException> { model.isLeaf("not a node") }
-                .message should matchBundle("template_list.error.must_be_state_node")
+                .message should matchBundle("template_list.error.unknown_node_type")
+        }
+
+        test("throws an error if the given node is not contained in the model") {
+            shouldThrow<IllegalArgumentException> { model.isLeaf(StateNode(DummyScheme())) }
+                .message should matchBundle("template_list.error.node_not_in_tree")
         }
 
         withData(
             mapOf(
-                "cannot have children" to row(model.root.children[0].children[1], true),
-                "can have children, but has none" to row(model.root.children[2], true),
-                "can have children and has children" to row(model.root.children[0], false),
+                "cannot have children" to row({ model.root.children[0].children[1] }, true),
+                "can have children, but has none" to row({ model.root.children[2] }, true),
+                "can have children and has children" to row({ model.root.children[0] }, false),
             )
-        ) { (state, expected) -> model.isLeaf(state) shouldBe expected }
+        ) { (state, expected) -> model.isLeaf(state()) shouldBe expected }
     }
 
     context("getChild") {
         test("throws an error if the given node is not a StateNode") {
             shouldThrow<IllegalArgumentException> { model.getChild("not a node", index = 0) }
-                .message should matchBundle("template_list.error.must_be_state_node")
+                .message should matchBundle("template_list.error.unknown_node_type")
+        }
+
+        test("throws an error if the given node is not contained in the model") {
+            shouldThrow<IllegalArgumentException> { model.getChild(StateNode(DummyScheme()), 4) }
+                .message should matchBundle("template_list.error.node_not_in_tree")
         }
 
         test("throws an error if the given node cannot have children") {
-            shouldThrow<IllegalArgumentException> { model.getChild(model.root.children[0].children[1], index = 0) }
-                .message should matchBundle("template_list.error.child_of_infertile_parent")
+            shouldThrow<IllegalStateException> { model.getChild(model.root.children[0].children[1], index = 0) }
+                .message should matchBundle("template_list.error.infertile_parent")
         }
 
         test("throws an error if there is no child at the given index") {
@@ -232,52 +342,49 @@ object TemplateJTreeModelTest : FunSpec({
         }
 
         test("returns the child at the given index") {
-            model.getChild(model.root.children[1], index = 0).state shouldBe model.list.templates[1].schemes[0]
+            model.getChild(model.root.children[1], index = 0).state shouldBe list.templates[1].schemes[0]
         }
     }
 
     context("getChildCount") {
         test("throws an error if the given node is not a StateNode") {
             shouldThrow<IllegalArgumentException> { model.getChildCount("not a node") }
-                .message should matchBundle("template_list.error.must_be_state_node")
+                .message should matchBundle("template_list.error.unknown_node_type")
+        }
+
+        test("throws an error if the given node is not contained in the model") {
+            shouldThrow<IllegalArgumentException> { model.getChildCount(StateNode(DummyScheme())) }
+                .message should matchBundle("template_list.error.node_not_in_tree")
         }
 
         withData(
             mapOf(
-                "cannot have children" to row(model.root.children[0].children[1], 0),
-                "can have children, but has none" to row(model.root.children[2], 0),
-                "can have children and has children" to row(model.root.children[0], 2),
+                "cannot have children" to row({ model.root.children[0].children[1] }, 0),
+                "can have children, but has none" to row({ model.root.children[2] }, 0),
+                "can have children and has children" to row({ model.root.children[0] }, 2),
             )
-        ) { (state, expected) -> model.getChildCount(state) shouldBe expected }
+        ) { (state, expected) -> model.getChildCount(state()) shouldBe expected }
     }
 
     context("getIndexOfChild") {
-        test("throws an error if the parent is not a StateNode") {
-            val child = model.root.children[0].children[1]
-
-            shouldThrow<IllegalArgumentException> { model.getIndexOfChild("not a node", child) }
-                .message should matchBundle("template_list.error.must_be_state_node", "Parent")
-        }
-
-        test("throws an error if the child is not a StateNode") {
-            shouldThrow<IllegalArgumentException> { model.getIndexOfChild(model.root.children[0], "not a node") }
-                .message should matchBundle("template_list.error.must_be_state_node", "Child")
-        }
-
         withData(
-            mapOf<String, Row3<() -> StateNode?, () -> StateNode?, Int>>(
+            mapOf<String, Row3<() -> Any?, () -> Any?, Int>>(
+                "parent is not a StateNode" to
+                    row({ "parent" }, { model.root.children[0].children[0] }, -1),
+                "child is not a StateNode" to
+                    row({ model.root.children[1] }, { "child" }, -1),
                 "parent is null" to
                     row({ null }, { model.root.children[1].children[0] }, -1),
                 "child is null" to
                     row({ model.root.children[1] }, { null }, -1),
                 "parent is not child's parent" to
-                    row({ model.root.children[1] }, { model.root.children[0].children[1] }, -1),
+                    row({ model.root.children[2] }, { model.root.children[0].children[1] }, -1),
                 "parent is child's parent" to
                     row({ model.root.children[1] }, { model.root.children[1].children[0] }, 0),
-                "parent looks at UUID for matching" to
+                "parent matches by UUID only" to
                     row(
                         { model.root.children[0] },
-                        { StateNode(model.list.templates[0].schemes[1].deepCopy(retainUuid = true)) },
+                        { StateNode(list.templates[0].schemes[1].deepCopy(retainUuid = true)) },
                         1,
                     ),
             )
@@ -285,9 +392,9 @@ object TemplateJTreeModelTest : FunSpec({
     }
 
     context("getParentOf") {
-        test("returns an error if the node is not contained in this model") {
+        test("throws an error if the node is not contained in this model") {
             shouldThrow<IllegalArgumentException> { model.getParentOf(StateNode(DummyScheme())) }
-                .message should matchBundle("template_list.error.parent_of_node_not_in_model")
+                .message should matchBundle("template_list.error.node_not_in_tree")
         }
 
         withData(
@@ -300,9 +407,9 @@ object TemplateJTreeModelTest : FunSpec({
     }
 
     context("getPathToRoot") {
-        test("returns an error if the node is not contained in this model") {
+        test("throws an error if the node is not contained in this model") {
             shouldThrow<IllegalArgumentException> { model.getPathToRoot(StateNode(DummyScheme())) }
-                .message should matchBundle("template_list.error.path_of_node_not_in_model")
+                .message should matchBundle("template_list.error.node_not_in_tree")
         }
 
         withData(
@@ -321,128 +428,6 @@ object TemplateJTreeModelTest : FunSpec({
     }
 
 
-    context("insertNode") {
-        test("throws an error when a node is inserted at a negative index") {
-            shouldThrow<IndexOutOfBoundsException> { model.insertNode(model.root, StateNode(Template()), index = -2) }
-        }
-
-        test("throws an error if a node is inserted at a too-high index") {
-            shouldThrow<IndexOutOfBoundsException> { model.insertNode(model.root, StateNode(Template()), index = 14) }
-        }
-
-
-        test("inserts a node at a specific index") {
-            val node = StateNode(Template("Template3"))
-
-            model.insertNode(model.root, node, index = 1)
-
-            model.root.children shouldHaveSize 4
-            model.root.children[1] shouldBe node
-            model.list.templates.names() shouldContainExactly listOf("Template0", "Template3", "Template1", "Template2")
-        }
-
-        test("inserts a node at the last index of the parent") {
-            val node = StateNode(Template("Template3"))
-
-            model.insertNode(model.root, node, index = 3)
-
-            model.root.children shouldHaveSize 4
-            model.root.children[3] shouldBe node
-            model.list.templates.names() shouldContainExactly listOf("Template0", "Template1", "Template2", "Template3")
-        }
-
-
-        test("informs listeners of the insertion") {
-            var lastEvent: TreeModelEvent? = null
-            model.addTreeModelListener(SimpleTreeModelListener { lastEvent = it })
-
-            val scheme = StateNode(DummyScheme())
-            model.insertNode(model.root.children[0], scheme)
-
-            lastEvent!!.treePath.lastPathComponent shouldBe model.root.children[0]
-            lastEvent!!.childIndices shouldContainExactly arrayOf(2)
-            lastEvent!!.children shouldContainExactly arrayOf(scheme)
-        }
-
-        test("informs listeners of a node insertion if the root's not-only child was inserted") {
-            var lastEvent: TreeModelEvent? = null
-            model.addTreeModelListener(SimpleTreeModelListener { lastEvent = it })
-
-            val node = StateNode(Template("Template3"))
-            model.insertNode(model.root, node, index = 1)
-
-            lastEvent!!.treePath.lastPathComponent shouldBe model.root
-            lastEvent!!.childIndices shouldContainExactly arrayOf(1)
-            lastEvent!!.children shouldContainExactly arrayOf(node)
-        }
-
-        test("informs listeners of a structure change if the root's now-only child was inserted") {
-            model.reload(TemplateList(mutableListOf()))
-
-            var lastEvent: TreeModelEvent? = null
-            model.addTreeModelListener(SimpleTreeModelListener { lastEvent = it })
-
-            val node = StateNode(Template("Template3"))
-            model.insertNode(model.root, node)
-
-            lastEvent!!.treePath.lastPathComponent shouldBe model.root
-            lastEvent!!.childIndices should beEmptyIntArray()
-            lastEvent!!.children should beNull()
-        }
-    }
-
-    context("insertNodeAfter") {
-        test("throws an error if the node to insert after is not in the parent") {
-            shouldThrow<IllegalArgumentException> {
-                model.insertNodeAfter(model.root, StateNode(Template()), StateNode(DummyScheme()))
-            }.message should matchBundle("template_list.error.find_node_insert_parent")
-        }
-
-        test("inserts the node after the given node") {
-            val node = StateNode(Template("Family"))
-
-            model.insertNodeAfter(model.root, node, model.root.children[1])
-
-            model.root.children[2] shouldBe node
-        }
-    }
-
-    context("removeNode") {
-        test("throws an error if the given node is not contained in the model") {
-            shouldThrow<IllegalArgumentException> { model.removeNode(StateNode(DummyScheme())) }
-                .message should matchBundle("template_list.error.remove_node_not_in_model")
-        }
-
-        test("throws an error if the given node is the root of the model") {
-            shouldThrow<IllegalArgumentException> { model.removeNode(model.root) }
-                .message should matchBundle("template_list.error.remove_root")
-        }
-
-        test("removes a node from the model and the underlying list") {
-            val node = model.root.children[1]
-
-            model.removeNode(node)
-
-            model.root.children shouldHaveSize 2
-            model.root.children shouldNotContain node
-            model.list.templates shouldHaveSize 2
-            model.list.templates shouldNotContain node.state
-        }
-
-        test("informs listeners of the removal") {
-            val node = model.root.children[2]
-
-            var lastEvent: TreeModelEvent? = null
-            model.addTreeModelListener(SimpleTreeModelListener { lastEvent = it })
-            model.removeNode(node)
-
-            lastEvent!!.treePath.lastPathComponent shouldBe model.root
-            lastEvent!!.childIndices shouldContainExactly arrayOf(2)
-            lastEvent!!.children shouldContainExactly arrayOf(node)
-        }
-    }
-
-
     context("fire methods") {
         var nodesChangedInvoked = 0
         var nodesInsertedInvoked = 0
@@ -522,7 +507,7 @@ object TemplateJTreeModelTest : FunSpec({
                 val node = StateNode(DummyScheme())
 
                 shouldThrow<IllegalArgumentException> { model.fireNodeInserted(model.root, node, 688) }
-                    .message should matchBundle("template_list.error.insert_list")
+                    .message should matchBundle("template_list.error.cannot_insert_root")
             }
 
             test("does nothing if the given node is null") {
@@ -556,7 +541,7 @@ object TemplateJTreeModelTest : FunSpec({
                 val node = StateNode(DummyScheme())
 
                 shouldThrow<IllegalArgumentException> { model.fireNodeRemoved(model.root, node, 888) }
-                    .message should matchBundle("template_list.error.remove_list")
+                    .message should matchBundle("template_list.error.cannot_remove_root")
             }
 
             test("fires an event with the given parent, node, and index") {
@@ -574,12 +559,6 @@ object TemplateJTreeModelTest : FunSpec({
         }
 
         context("fireNodeStructureChanged") {
-            test("does nothing if the given node is null") {
-                model.fireNodeStructureChanged(null)
-
-                totalInvoked shouldBe 0
-            }
-
             test("fires an event with the given node") {
                 val node = model.root.children[0]
 
@@ -597,9 +576,9 @@ object TemplateJTreeModelTest : FunSpec({
 
     context("valueForPathChanged") {
         test("throws an error") {
-            val rootPath = model.getPathToRoot(model.root)
-            shouldThrow<UnsupportedOperationException> { model.valueForPathChanged(rootPath, "dirt") }
-                .message should matchBundle("template_list.error.change_value_by_path")
+            shouldThrow<UnsupportedOperationException> {
+                model.valueForPathChanged(model.getPathToRoot(model.root), "new-value")
+            }
         }
     }
 
@@ -609,7 +588,7 @@ object TemplateJTreeModelTest : FunSpec({
             val listener = SimpleTreeModelListener { invoked++ }
 
             model.addTreeModelListener(listener)
-            model.reload()
+            model.fireNodeStructureChanged()
 
             invoked shouldBe 1
         }
@@ -621,10 +600,10 @@ object TemplateJTreeModelTest : FunSpec({
             val listener = SimpleTreeModelListener { invoked++ }
 
             model.addTreeModelListener(listener)
-            model.reload()
+            model.fireNodeStructureChanged()
 
             model.removeTreeModelListener(listener)
-            model.reload()
+            model.fireNodeStructureChanged()
 
             invoked shouldBe 1
         }
@@ -647,11 +626,6 @@ object StateNodeTest : FunSpec({
 
     context("children") {
         context("get") {
-            test("throws an error for a non-template scheme") {
-                shouldThrow<IllegalStateException> { StateNode(DummyScheme()).children }
-                    .message should matchBundle("template_list.error.unknown_state_type", "parent")
-            }
-
             test("returns the templates of a template list") {
                 val templates = mutableListOf(Template("Template0"), Template("Template2"))
 
@@ -667,20 +641,21 @@ object StateNodeTest : FunSpec({
 
                 node.children.map { it.state } shouldContainExactly schemes
             }
-        }
 
-        context("set") {
             test("throws an error for a non-template scheme") {
-                shouldThrow<IllegalStateException> { run { StateNode(DummyScheme()).children = emptyList() } }
-                    .message should matchBundle("template_list.error.unknown_state_type", "parent")
+                shouldThrow<IllegalStateException> { StateNode(DummyScheme()).children }
+                    .message should matchBundle("template_list.error.infertile_parent")
             }
+        }
 
+        context("set") {
             test("modifies the templates of a template list") {
                 val list = TemplateList(mutableListOf(Template("Template0"), Template("Template1")))
 
-                StateNode(list).children = listOf(StateNode(Template("NewTemplate")))
+                val newTemplate = Template("NewTemplate")
+                StateNode(list).children = listOf(StateNode(newTemplate))
 
-                list.templates.map { it.name } shouldContainExactly listOf("NewTemplate")
+                list.templates shouldContainExactly listOf(newTemplate)
             }
 
             test("modifies the schemes of a template") {
@@ -691,81 +666,55 @@ object StateNodeTest : FunSpec({
 
                 template.schemes shouldContainExactly listOf(newScheme)
             }
+
+            test("throws an error for a non-template scheme") {
+                shouldThrow<IllegalStateException> { run { StateNode(DummyScheme()).children = emptyList() } }
+                    .message should matchBundle("template_list.error.infertile_parent")
+            }
         }
     }
 
-    context("recursiveChildren") {
+    context("descendants") {
         test("returns the templates and schemes of a template list in depth-first order") {
             val templates = mutableListOf(
                 Template("Template0", mutableListOf(DummyScheme("Scheme0"), DummyScheme("Scheme1"))),
                 Template("Template1", mutableListOf(DummyScheme("Scheme1"))),
             )
 
-            val children = StateNode(TemplateList(templates)).recursiveChildren
+            val children = StateNode(TemplateList(templates)).descendants
 
-            val names = listOf("Template0", "Scheme0", "Scheme1", "Template1", "Scheme1")
-            children.map { (it.state as Scheme).name } shouldContainExactly names
+            children.map { (it.state as Scheme).name } shouldContainExactly
+                listOf("Template0", "Scheme0", "Scheme1", "Template1", "Scheme1")
         }
 
         test("returns the schemes of a template") {
             val schemes = mutableListOf<Scheme>(DummyScheme("Scheme0"), DummyScheme("Scheme1"))
 
-            val children = StateNode(Template(schemes = schemes)).recursiveChildren
+            val children = StateNode(Template(schemes = schemes)).descendants
 
-            children.map { (it.state as Scheme).name } shouldContainExactly listOf("Scheme0", "Scheme1")
+            children.map { (it.state as Scheme).name } shouldContainExactly schemes.map { it.name }
         }
 
         test("returns an empty list if the node cannot have children") {
-            StateNode(DummyScheme()).recursiveChildren should beEmpty()
+            StateNode(DummyScheme()).descendants should beEmpty()
         }
     }
 
 
-    context("contains") {
+    context("canHaveChild") {
         withData(
             mapOf(
-                "list: contains itself" to
-                    row(TemplateList(), { it }, true),
-                "list: contains other list" to
-                    row(TemplateList(), { TemplateList() }, false),
-                "list: contains child template" to
-                    row(TemplateList(mutableListOf(Template())), { (it as TemplateList).templates[0] }, true),
-                "list: contains non-child template" to
-                    row(TemplateList(mutableListOf(Template("Child"))), { Template("Other") }, false),
-                "list: contains child scheme" to
-                    row(
-                        TemplateList(mutableListOf(Template(schemes = mutableListOf(DummyScheme())))),
-                        { (it as TemplateList).templates[0].schemes[0] },
-                        true,
-                    ),
-                "list: contains non-child scheme" to
-                    row(
-                        TemplateList(mutableListOf(Template(schemes = mutableListOf(DummyScheme())))),
-                        { DummyScheme() },
-                        false,
-                    ),
-                "template: contains template list" to
-                    row(Template(), { TemplateList() }, false),
-                "template: contains itself" to
-                    row(Template(), { it }, true),
-                "template: contains other template" to
-                    row(Template(), { Template() }, false),
-                "template: contains child scheme" to
-                    row(Template(schemes = mutableListOf(DummyScheme())), { (it as Template).schemes[0] }, true),
-                "template: contains non-child scheme" to
-                    row(Template(schemes = mutableListOf(DummyScheme())), { DummyScheme() }, false),
-                "scheme: contains template list" to
-                    row(DummyScheme(), { TemplateList() }, false),
-                "scheme: contains template" to
-                    row(DummyScheme(), { Template() }, false),
-                "scheme: contains itself" to
-                    row(DummyScheme(), { it }, true),
-                "scheme: contains other scheme" to
-                    row(DummyScheme(), { DummyScheme() }, false),
+                "TemplateList/TemplateList" to row(TemplateList(mutableListOf()), TemplateList(mutableListOf()), false),
+                "TemplateList/Template" to row(TemplateList(mutableListOf()), Template(), true),
+                "TemplateList/Scheme" to row(TemplateList(mutableListOf()), DummyScheme(), false),
+                "Template/TemplateList" to row(Template(), TemplateList(mutableListOf()), false),
+                "Template/Template" to row(Template(), Template(), false),
+                "Template/Scheme" to row(Template(), DummyScheme(), true),
+                "Scheme/TemplateList" to row(DummyScheme(), TemplateList(mutableListOf()), false),
+                "Scheme/Template" to row(DummyScheme(), Template(), false),
+                "Scheme/Scheme" to row(DummyScheme(), DummyScheme(), false),
             )
-        ) { (parent, getChild, expected): Row3<State, (State) -> State, Boolean> ->
-            StateNode(parent).contains(StateNode(getChild(parent))) shouldBe expected
-        }
+        ) { (parent, child, expected) -> StateNode(parent).canHaveChild(StateNode(child)) shouldBe expected }
     }
 
 
@@ -780,16 +729,20 @@ object StateNodeTest : FunSpec({
             node shouldBe node
         }
 
-        test("equals an identical object") {
+        test("equals a node of a copy with the same UUID") {
             val scheme = DummyScheme()
 
-            StateNode(scheme) shouldBe StateNode(scheme)
+            StateNode(scheme) shouldBe StateNode(scheme.deepCopy(retainUuid = true))
         }
 
-        test("does not equal a different object") {
-            val node = StateNode(DummyScheme())
+        test("does not equal a node of a copy with a different UUID") {
+            val scheme = DummyScheme()
 
-            node shouldNotBe StateNode(DummyScheme())
+            StateNode(scheme) shouldNotBe StateNode(scheme.deepCopy(retainUuid = false))
+        }
+
+        test("does not equal a different object with a different UUID") {
+            StateNode(DummyScheme()) shouldNotBe StateNode(DummyScheme())
         }
     }
 
@@ -818,6 +771,15 @@ object StateNodeTest : FunSpec({
             node1.hashCode() shouldBe node2.hashCode()
         }
 
+        test("does not equal the hashcode of a deep copy with the same UUID") {
+            val scheme = DummyScheme()
+
+            val node1 = StateNode(scheme)
+            val node2 = StateNode(scheme.deepCopy(retainUuid = false))
+
+            node1.hashCode() shouldNotBe node2.hashCode()
+        }
+
         test("does not equal the hashcode of a different object") {
             val node1 = StateNode(DummyScheme())
             val node2 = StateNode(DummyScheme())
diff --git a/src/test/kotlin/com/fwdekker/randomness/template/TemplateJTreeTest.kt b/src/test/kotlin/com/fwdekker/randomness/template/TemplateJTreeTest.kt
index bc04985a2..83555329b 100644
--- a/src/test/kotlin/com/fwdekker/randomness/template/TemplateJTreeTest.kt
+++ b/src/test/kotlin/com/fwdekker/randomness/template/TemplateJTreeTest.kt
@@ -10,6 +10,7 @@ import com.fwdekker.randomness.testhelpers.getActionButton
 import com.fwdekker.randomness.testhelpers.guiGet
 import com.fwdekker.randomness.testhelpers.guiRun
 import com.fwdekker.randomness.testhelpers.matchBundle
+import com.fwdekker.randomness.testhelpers.shouldContainExactly
 import com.intellij.openapi.actionSystem.ActionToolbar
 import com.intellij.testFramework.fixtures.IdeaTestFixture
 import com.intellij.testFramework.fixtures.IdeaTestFixtureFactory
@@ -19,6 +20,7 @@ import io.kotest.core.spec.style.FunSpec
 import io.kotest.data.Row3
 import io.kotest.data.row
 import io.kotest.datatest.withData
+import io.kotest.matchers.collections.shouldContain
 import io.kotest.matchers.collections.shouldContainExactly
 import io.kotest.matchers.collections.shouldNotContain
 import io.kotest.matchers.nulls.beNull
@@ -35,14 +37,16 @@ import org.assertj.swing.fixture.FrameFixture
 /**
  * Unit tests for [TemplateJTree].
  */
+@Suppress("detekt:LargeClass") // Would be weird to split up given that CUT is not split up either
 object TemplateJTreeTest : FunSpec({
     tags(NamedTag("IdeaFixture"), NamedTag("Swing"))
 
 
     lateinit var ideaFixture: IdeaTestFixture
+    lateinit var frame: FrameFixture
 
-    lateinit var originalSettings: Settings
-    lateinit var currentSettings: Settings
+    lateinit var originalList: TemplateList
+    lateinit var currentList: TemplateList
     lateinit var tree: TemplateJTree
 
     fun List<Scheme>.names() = this.map { it.name }
@@ -56,23 +60,25 @@ object TemplateJTreeTest : FunSpec({
         ideaFixture = IdeaTestFixtureFactory.getFixtureFactory().createBareFixture()
         ideaFixture.setUp()
 
-        originalSettings =
-            Settings(
-                templateList = TemplateList(
-                    mutableListOf(
-                        Template("Template0", mutableListOf(DummyScheme("Scheme0"), DummyScheme("Scheme1"))),
-                        Template("Template1", mutableListOf(DummyScheme("Scheme2"))),
-                        Template("Template2", mutableListOf(DummyScheme("Scheme3"), DummyScheme("Scheme4"))),
-                    )
-                ),
+        originalList =
+            TemplateList(
+                mutableListOf(
+                    Template("Template0", mutableListOf(DummyScheme("Scheme0"), DummyScheme("Scheme1"))),
+                    Template("Template1", mutableListOf(DummyScheme("Scheme2"))),
+                    Template("Template2", mutableListOf(DummyScheme("Scheme3"), DummyScheme("Scheme4"))),
+                )
             )
-        originalSettings.applyContext(originalSettings)
-        currentSettings = originalSettings.deepCopy(retainUuid = true)
+        originalList.applyContext(Settings(templateList = originalList))
 
-        tree = guiGet { TemplateJTree(originalSettings, currentSettings) }
+        currentList = originalList.deepCopy(retainUuid = true)
+        currentList.applyContext(Settings(templateList = currentList))
+
+        tree = guiGet { TemplateJTree(originalList, currentList) }
+        frame = showInFrame(tree)
     }
 
     afterNonContainer {
+        frame.cleanUp()
         ideaFixture.tearDown()
     }
 
@@ -84,16 +90,10 @@ object TemplateJTreeTest : FunSpec({
             tree.selectedNodeNotRoot should beNull()
         }
 
-        test("returns null if the root is selected") {
-            guiRun { tree.selectionPath = tree.myModel.getPathToRoot(tree.myModel.root) }
-
-            tree.selectedNodeNotRoot should beNull()
-        }
-
         test("returns the selected node otherwise") {
-            val node = StateNode(tree.myModel.list.templates[0])
+            val node = StateNode(currentList.templates[0])
 
-            guiRun { tree.selectionPath = tree.myModel.getPathToRoot(node) }
+            guiRun { tree.selectionRows = intArrayOf(0) }
 
             tree.selectedNodeNotRoot shouldBe node
         }
@@ -107,14 +107,8 @@ object TemplateJTreeTest : FunSpec({
                 tree.selectedScheme should beNull()
             }
 
-            test("returns null if the root is selected") {
-                guiRun { tree.selectionPath = tree.myModel.getPathToRoot(tree.myModel.root) }
-
-                tree.selectedScheme should beNull()
-            }
-
             test("returns the selected scheme otherwise") {
-                val template = tree.myModel.list.templates[0]
+                val template = currentList.templates[0]
 
                 guiRun { tree.selectionPath = tree.myModel.getPathToRoot(StateNode(template)) }
 
@@ -123,45 +117,41 @@ object TemplateJTreeTest : FunSpec({
         }
 
         context("set") {
-            test("selects the first template if null is set") {
+            test("removes the selection if null is set") {
                 guiRun { tree.selectedScheme = null }
 
-                tree.selectedScheme shouldBe tree.myModel.list.templates[0]
-            }
-
-            test("selects the root if null is set and there are no templates") {
-                guiRun {
-                    tree.myModel.list.templates.clear()
-                    tree.reload()
-                    tree.selectedScheme = null
-                }
-
-                tree.selectedScheme should beNull()
+                tree.selectionCount shouldBe 0
             }
 
-            test("selects the first template if the scheme cannot be found") {
+            test("removes the selection if the scheme cannot be found") {
                 guiRun { tree.selectedScheme = DummyScheme("Not In Tree") }
 
-                tree.selectedScheme shouldBe tree.myModel.list.templates[0]
+                tree.selectionCount shouldBe 0
             }
 
-            test("selects the root if the scheme cannot be found and there are no templates") {
+            test("selects the given scheme otherwise") {
+                val scheme = currentList.templates[1].schemes[0]
+
                 guiRun {
-                    tree.myModel.list.templates.clear()
-                    tree.reload()
-                    tree.selectedScheme = DummyScheme("Not In Tree")
+                    tree.expandRow(1)
+                    tree.selectedScheme = scheme
                 }
 
-                tree.selectedScheme should beNull()
+                tree.selectionRows!! shouldContainExactly arrayOf(2)
             }
+        }
 
-            test("selects the given scheme if it exists") {
-                val scheme = tree.myModel.list.templates[1].schemes[0]
-
-                guiRun { tree.selectedScheme = scheme }
+        test("selects the scheme by its UUID") {
+            val copy = currentList.templates[0].schemes[1].deepCopy(retainUuid = true)
+            (copy as DummyScheme).name = "New Name"
 
-                tree.selectedScheme shouldBe scheme
+            guiRun {
+                tree.expandRow(0)
+                tree.selectedScheme = copy
             }
+
+            guiGet { tree.selectedScheme?.uuid } shouldBe copy.uuid
+            guiGet { tree.selectedScheme } shouldNotBe copy
         }
     }
 
@@ -173,52 +163,39 @@ object TemplateJTreeTest : FunSpec({
                 tree.selectedTemplate should beNull()
             }
 
-            test("returns null if the root is selected") {
-                guiRun { tree.selectionPath = tree.myModel.getPathToRoot(tree.myModel.root) }
-
-                tree.selectedTemplate should beNull()
-            }
-
             test("returns the parent template if a non-template scheme is selected") {
-                val scheme = tree.myModel.list.templates[2].schemes[0]
-
-                guiRun { tree.selectionPath = tree.myModel.getPathToRoot(StateNode(scheme)) }
+                guiRun {
+                    tree.expandRow(2)
+                    tree.selectionRows = intArrayOf(3)
+                }
 
-                tree.selectedTemplate shouldBe tree.myModel.list.templates[2]
+                tree.selectedTemplate shouldBe currentList.templates[2]
             }
 
             test("returns the selected template otherwise") {
-                val template = tree.myModel.list.templates[0]
-
-                guiRun { tree.selectionPath = tree.myModel.getPathToRoot(StateNode(template)) }
+                guiRun { tree.selectionRows = intArrayOf(1) }
 
-                tree.selectedTemplate shouldBe template
+                tree.selectedTemplate shouldBe currentList.templates[1]
             }
         }
 
         context("set") {
-            test("selects the first template if null is set") {
+            test("removes the selection if null is set") {
                 guiRun { tree.selectedTemplate = null }
 
-                tree.selectedTemplate shouldBe tree.myModel.list.templates[0]
+                tree.selectionCount shouldBe 0
             }
 
-            test("selects the root if null is set and there are no templates") {
-                guiRun {
-                    tree.myModel.list.templates.clear()
-                    tree.reload()
-                    tree.selectedTemplate = null
-                }
+            test("removes the selection if the template cannot be found") {
+                guiRun { tree.selectedTemplate = Template("New Template") }
 
-                tree.selectedTemplate should beNull()
+                tree.selectionCount shouldBe 0
             }
 
             test("selects the given template if it exists") {
-                val template = tree.myModel.list.templates[1]
+                guiRun { tree.selectedTemplate = currentList.templates[2] }
 
-                guiRun { tree.selectedTemplate = template }
-
-                tree.selectedTemplate shouldBe template
+                tree.selectionRows!! shouldContainExactly arrayOf(2)
             }
         }
     }
@@ -226,40 +203,57 @@ object TemplateJTreeTest : FunSpec({
 
     context("reload") {
         test("synchronizes removed nodes") {
-            guiRun { tree.myModel.list.templates.removeAll(tree.myModel.list.templates.take(2)) }
-            guiGet { tree.rowCount } shouldBe 8
+            guiRun { currentList.templates.remove(currentList.templates[2]) }
+            guiGet { tree.rowCount } shouldBe 3
 
             guiRun { tree.reload() }
 
-            guiGet { tree.rowCount } shouldBe 3
+            guiGet { tree.rowCount } shouldBe 2
         }
 
         test("synchronizes added nodes") {
-            guiRun { tree.myModel.list.templates += Template("New Template", mutableListOf(DummyScheme("New Scheme"))) }
-            guiGet { tree.rowCount } shouldBe 8
+            guiRun { currentList.templates += Template("New Template", mutableListOf(DummyScheme("New Scheme"))) }
+            guiGet { tree.rowCount } shouldBe 3
 
             guiRun { tree.reload() }
 
-            guiGet { tree.rowCount } shouldBe 10
+            guiGet { tree.rowCount } shouldBe 5 // Including new scheme
         }
 
         test("retains the scheme selection") {
-            guiRun { tree.selectedScheme = tree.myModel.list.templates[1].schemes[0] }
+            guiRun {
+                tree.expandRow(0)
+                tree.selectedScheme = currentList.templates[1].schemes[0]
+            }
 
             guiRun { tree.reload() }
 
-            tree.selectedScheme shouldBe tree.myModel.list.templates[1].schemes[0]
+            tree.selectedScheme shouldBe currentList.templates[1].schemes[0]
+        }
+
+        test("resets the selected scheme's state to the original") {
+            guiRun {
+                tree.expandRow(0)
+                tree.selectedScheme = currentList.templates[1].schemes[0]
+            }
+
+            guiRun { tree.reload() }
+
+            tree.selectedScheme shouldBe originalList.templates[1].schemes[0]
         }
 
         test("selects the first template if the selected node was removed") {
-            guiRun { tree.selectedScheme = tree.myModel.list.templates[1].schemes[0] }
+            guiRun {
+                tree.expandRow(1)
+                tree.selectedScheme = currentList.templates[1].schemes[0]
+            }
 
             guiRun {
-                tree.myModel.list.templates[1].schemes.clear()
+                currentList.templates[1].schemes.clear()
                 tree.reload()
             }
 
-            tree.selectedScheme shouldBe tree.myModel.list.templates[0]
+            tree.selectedScheme shouldBe currentList.templates[0]
         }
 
         test("selects the first template if no node was selected before") {
@@ -267,7 +261,7 @@ object TemplateJTreeTest : FunSpec({
 
             guiRun { tree.reload() }
 
-            tree.selectedScheme shouldBe tree.myModel.list.templates[0]
+            tree.selectedScheme shouldBe currentList.templates[0]
         }
 
         test("keeps collapsed nodes collapsed") {
@@ -288,175 +282,331 @@ object TemplateJTreeTest : FunSpec({
             guiGet { tree.isExpanded(0) } shouldBe true
         }
 
-        test("expands new nodes") {
+        test("expands new templates") {
             val template = Template("New Template", mutableListOf(DummyScheme("New Scheme")))
-            guiRun { tree.myModel.list.templates += template }
+            guiRun { currentList.templates += template }
 
             guiRun { tree.reload() }
 
-            guiGet { tree.myModel.rowToNode(8)!!.state } shouldBe template
-            guiGet { tree.isExpanded(8) } shouldBe true
+            guiGet { (tree.getPathForRow(3).lastPathComponent as StateNode).state } shouldBe template
+            guiGet { tree.isExpanded(3) } shouldBe true
+        }
+    }
+
+    context("expandAll") {
+        test("collapses all templates if an empty list is given") {
+            guiRun { tree.expandNodes(emptyList()) }
+
+            guiGet { tree.isExpanded(0) } shouldBe false
+            guiGet { tree.isExpanded(1) } shouldBe false
+            guiGet { tree.isExpanded(2) } shouldBe false
+        }
+
+        test("expands all templates if a full list is given") {
+            guiRun { tree.expandNodes(currentList.templates.map { it.uuid }) }
+
+            guiGet { tree.isExpanded(0) } shouldBe true
+            guiGet { tree.isExpanded(3) } shouldBe true
+            guiGet { tree.isExpanded(5) } shouldBe true
+        }
+
+        test("expands the given nodes and collapses all other nodes") {
+            guiRun {
+                tree.collapseRow(0)
+                tree.collapseRow(1)
+                tree.expandRow(2)
+            }
+            guiGet { tree.rowCount } shouldBe 5
+
+            guiRun { tree.expandNodes(currentList.templates.take(2).map { it.uuid }) }
+
+            guiGet { tree.isExpanded(0) } shouldBe true
+            guiGet { tree.isExpanded(3) } shouldBe true
+            guiGet { tree.isExpanded(5) } shouldBe false
         }
     }
 
 
     context("addScheme") {
         context("unique name") {
-            test("appends (1) if a scheme with the given name already exists") {
+            test("appends (1) if a template with the given name already exists") {
                 guiRun { tree.addScheme(Template("Template0")) }
 
-                tree.myModel.list.templates[1].name shouldBe "Template0 (1)"
+                currentList.templates[1].name shouldBe "Template0 (1)"
             }
 
-            test("appends (2) if two schemes with the given name already exist") {
+            test("appends (2) if two templates with the given name already exist") {
                 guiRun {
                     tree.addScheme(Template("Template0"))
                     tree.addScheme(Template("Template0"))
                 }
 
-                tree.myModel.list.templates[2].name shouldBe "Template0 (2)"
+                currentList.templates[2].name shouldBe "Template0 (2)"
             }
 
-            test("appends (2) if a scheme ending with (1) already exists") {
+            test("appends (2) if a template ending with (1) already exists") {
                 guiRun {
                     tree.addScheme(Template("Template0 (1)"))
                     tree.addScheme(Template("Template0"))
                 }
 
-                tree.myModel.list.templates[2].name shouldBe "Template0 (2)"
+                currentList.templates[2].name shouldBe "Template0 (2)"
             }
 
-            test("replaces (1) with (2) if a scheme ending with (1) already exists") {
+            test("replaces (1) with (2) if a template ending with (1) already exists") {
                 guiRun {
                     tree.addScheme(Template("Template0 (1)"))
                     tree.addScheme(Template("Template0 (1)"))
                 }
 
-                tree.myModel.list.templates[2].name shouldBe "Template0 (2)"
+                currentList.templates[2].name shouldBe "Template0 (2)"
             }
 
-            test("replaces (13) with (14) if a scheme ending with (13) already exists") {
+            test("replaces (13) with (14) if a template ending with (13) already exists") {
                 guiRun {
                     tree.addScheme(Template("Template0 (13)"))
                     tree.addScheme(Template("Template0 (13)"))
                 }
 
-                tree.myModel.list.templates[2].name shouldBe "Template0 (14)"
+                currentList.templates[2].name shouldBe "Template0 (14)"
             }
         }
 
-        test("inserts the template at the bottom if nothing is selected") {
-            guiRun { tree.clearSelection() }
+        context("template") {
+            test("inserts the template at the bottom if nothing is selected") {
+                guiRun { tree.clearSelection() }
 
-            guiRun { tree.addScheme(Template("New Template")) }
+                guiRun { tree.addScheme(Template("New Template")) }
 
-            tree.myModel.list.templates.last().name shouldBe "New Template"
-        }
+                currentList.templates.last().name shouldBe "New Template"
+            }
 
-        test("fails if a scheme is inserted while nothing is selected") {
-            guiRun { tree.clearSelection() }
+            test("inserts the template below the selected template") {
+                guiRun { tree.selectedScheme = currentList.templates[1] }
 
-            shouldThrow<IllegalArgumentException> { tree.addScheme(DummyScheme()) }
-                .message should matchBundle("template_list.error.add_template_to_non_root")
-        }
+                guiRun { tree.addScheme(Template("New Template")) }
 
-        test("inserts the template below the selected template") {
-            guiRun { tree.selectedScheme = tree.myModel.list.templates[1] }
+                currentList.templates[2].name shouldBe "New Template"
+            }
 
-            guiRun { tree.addScheme(Template("New Template")) }
+            test("inserts the template below the selected scheme") {
+                guiRun {
+                    tree.expandRow(0)
+                    tree.selectedScheme = currentList.templates[0].schemes[1]
+                }
 
-            tree.myModel.list.templates[2].name shouldBe "New Template"
-        }
+                guiRun { tree.addScheme(Template("New Template")) }
 
-        test("inserts the scheme at the bottom of the selected template") {
-            guiRun { tree.selectedScheme = tree.myModel.list.templates[1] }
+                currentList.templates[1].name shouldBe "New Template"
+            }
 
-            guiRun { tree.addScheme(DummyScheme("New Scheme")) }
+            test("selects the inserted template") {
+                guiRun { tree.selectedScheme = currentList.templates[1] }
 
-            tree.myModel.list.templates[1].schemes.last().name shouldBe "New Scheme"
-        }
+                guiRun { tree.addScheme(Template("New Template")) }
 
-        test("inserts the template after the selected scheme") {
-            guiRun { tree.selectedScheme = tree.myModel.list.templates[0].schemes[1] }
+                currentList.templates[2].name shouldBe "New Template"
+            }
+
+            test("expands the inserted template") {
+                val template = Template("New Template", mutableListOf(DummyScheme("New Scheme")))
+                guiRun { tree.clearSelection() }
 
-            guiRun { tree.addScheme(Template("New Template")) }
+                guiRun { tree.addScheme(template) }
 
-            tree.myModel.list.templates[1].name shouldBe "New Template"
+                guiGet { (tree.getPathForRow(3).lastPathComponent as StateNode).state } shouldBe template
+                guiGet { tree.isExpanded(3) } shouldBe true
+            }
         }
 
-        test("inserts the scheme below the selected scheme") {
-            guiRun { tree.selectedScheme = tree.myModel.list.templates[2].schemes[0] }
+        context("scheme") {
+            test("fails if a scheme is inserted while nothing is selected") {
+                guiRun { tree.clearSelection() }
+
+                shouldThrow<IllegalArgumentException> { tree.addScheme(DummyScheme()) }
+                    .message should matchBundle("template_list.error.wrong_child_type")
+            }
 
-            guiRun { tree.addScheme(DummyScheme("New Scheme")) }
+            test("inserts the scheme at the bottom of the selected template") {
+                guiRun { tree.selectedScheme = currentList.templates[1] }
 
-            tree.myModel.list.templates[2].schemes[1].name shouldBe "New Scheme"
-        }
+                guiRun { tree.addScheme(DummyScheme("New Scheme")) }
+
+                currentList.templates[1].schemes.last().name shouldBe "New Scheme"
+            }
+
+            test("inserts the scheme below the selected scheme") {
+                guiRun {
+                    tree.expandRow(2)
+                    tree.selectedScheme = currentList.templates[2].schemes[0]
+                }
+
+                guiRun { tree.addScheme(DummyScheme("New Scheme")) }
+
+                currentList.templates[2].schemes[1].name shouldBe "New Scheme"
+            }
 
-        test("selects the inserted node") {
-            guiRun { tree.selectedScheme = tree.myModel.list.templates[1].schemes[0] }
+            test("selects the inserted scheme") {
+                guiRun {
+                    tree.expandRow(1)
+                    tree.selectedScheme = currentList.templates[1].schemes[0]
+                }
 
-            guiRun { tree.addScheme(DummyScheme()) }
+                guiRun { tree.addScheme(DummyScheme()) }
 
-            tree.selectedScheme shouldBe tree.myModel.list.templates[1].schemes[1]
+                tree.selectedScheme shouldBe currentList.templates[1].schemes[1]
+            }
         }
     }
 
     context("removeScheme") {
         test("removes the given node from the tree") {
-            guiRun { tree.removeScheme(tree.myModel.list.templates[1]) }
+            guiRun { tree.removeScheme(currentList.templates[1]) }
 
-            tree.myModel.list.templates.names() shouldContainExactly listOf("Template0", "Template2")
+            currentList.templates.names() shouldContainExactly listOf("Template0", "Template2")
         }
 
         test("removes the selection if there is nothing to select") {
-            guiRun { repeat(3) { tree.removeScheme(tree.myModel.list.templates[0]) } }
+            guiRun { repeat(3) { tree.removeScheme(currentList.templates[0]) } }
 
             tree.selectedScheme should beNull()
         }
 
         test("selects the parent if the removed node had no siblings left") {
-            guiRun { tree.removeScheme(tree.myModel.list.templates[1].schemes[0]) }
+            guiRun { tree.expandRow(1) }
+
+            guiRun { tree.removeScheme(currentList.templates[1].schemes[0]) }
 
             tree.selectedScheme?.name shouldBe "Template1"
         }
 
         test("selects the next sibling if the removed node has siblings") {
-            guiRun { tree.removeScheme(tree.myModel.list.templates[0].schemes[0]) }
+            guiRun { tree.expandRow(0) }
+
+            guiRun { tree.removeScheme(currentList.templates[0].schemes[0]) }
 
             tree.selectedScheme?.name shouldBe "Scheme1"
         }
     }
 
-    context("moveSchemeByOnePosition") {
-        test("moves a template") {
-            guiRun { tree.moveSchemeByOnePosition(tree.myModel.list.templates[1], moveDown = true) }
+    context("replaceScheme") {
+        test("removes the scheme if replaced with `null`") {
+            val scheme = currentList.templates[1]
+
+            guiRun { tree.replaceScheme(scheme, null) }
 
-            tree.myModel.list.templates.names() shouldContainExactly listOf("Template0", "Template2", "Template1")
+            currentList.templates shouldNotContain scheme
         }
 
-        test("moves a scheme") {
-            guiRun { tree.moveSchemeByOnePosition(tree.myModel.list.templates[0].schemes[1], moveDown = false) }
+        test("replaces the node with another node") {
+            val oldScheme = currentList.templates[2].schemes[1]
+            val newScheme = DummyScheme()
+
+            guiRun { tree.replaceScheme(oldScheme, newScheme) }
 
-            tree.myModel.list.templates[0].schemes.names() shouldContainExactly listOf("Scheme1", "Scheme0")
+            currentList.templates[2].schemes shouldNotContain oldScheme
+            currentList.templates[2].schemes shouldContain newScheme
         }
 
-        test("expands and selects the moved template") {
-            val template = tree.myModel.list.templates[2]
+        test("retains the current expansion state") {
+            guiRun { tree.expandRow(0) }
 
-            guiRun { tree.selectedTemplate = template }
-            guiRun { tree.moveSchemeByOnePosition(template, moveDown = false) }
+            guiRun { tree.replaceScheme(currentList.templates[0].schemes[1], DummyScheme()) }
 
-            val row = tree.myModel.nodeToRow(StateNode(template))
-            guiGet { tree.isExpanded(row) } shouldBe true // The `guiGet` is required
-            tree.isRowSelected(row) shouldBe true
+            guiGet { tree.isExpanded(0) } shouldBe true
         }
 
-        test("selects the moved scheme") {
-            val scheme = tree.myModel.list.templates[2].schemes[0]
+        test("retains the current selection") {
+            guiRun { tree.selectedScheme = currentList.templates[2] }
 
-            guiRun { tree.moveSchemeByOnePosition(scheme, moveDown = true) }
+            tree.replaceScheme(currentList.templates[1].schemes[0], DummyScheme())
 
-            tree.selectedScheme?.name shouldBe scheme.name
+            guiGet { tree.selectedScheme } shouldBe currentList.templates[2]
+        }
+    }
+
+    context("moveSchemeByOnePosition") {
+        context("template") {
+            test("moves a template") {
+                guiRun { tree.moveSchemeByOnePosition(currentList.templates[1], moveDown = true) }
+
+                currentList.templates.names() shouldContainExactly listOf("Template0", "Template2", "Template1")
+            }
+
+            test("selects the moved template") {
+                val template = currentList.templates[2]
+
+                guiRun { tree.selectedTemplate = template }
+                guiRun { tree.moveSchemeByOnePosition(template, moveDown = false) }
+
+                tree.selectedTemplate shouldBe template
+            }
+
+            test("keeps the moved template expanded") {
+                val template = currentList.templates[2]
+                guiRun { tree.expandRow(2) }
+
+                guiRun {
+                    tree.selectedTemplate = template
+                    tree.moveSchemeByOnePosition(template, moveDown = false)
+                }
+
+                guiGet { tree.isExpanded(1) } shouldBe true
+            }
+
+            test("keeps the moved template collapsed") {
+                guiRun { tree.collapseRow(2) }
+
+                guiRun {
+                    tree.selectedTemplate = currentList.templates[2]
+                    tree.moveSchemeByOnePosition(currentList.templates[2], moveDown = false)
+                }
+
+                guiGet { tree.isCollapsed(1) } shouldBe true
+            }
+        }
+
+        context("scheme") {
+            test("moves a scheme") {
+                guiRun { tree.expandRow(0) }
+
+                guiRun { tree.moveSchemeByOnePosition(currentList.templates[0].schemes[1], moveDown = false) }
+
+                currentList.templates[0].schemes.names() shouldContainExactly listOf("Scheme1", "Scheme0")
+            }
+
+            test("retains the selection after moving a scheme") {
+                val scheme = currentList.templates[2].schemes[0]
+                guiRun {
+                    tree.expandRow(2)
+                    tree.selectedScheme = scheme
+                }
+
+                guiRun { tree.moveSchemeByOnePosition(scheme, moveDown = true) }
+
+                tree.selectedScheme shouldBe scheme
+            }
+
+            test("keeps the scheme's parent expanded if the parent does not change") {
+                guiRun { tree.expandRow(0) }
+
+                guiRun { tree.moveSchemeByOnePosition(currentList.templates[0].schemes[1], moveDown = false) }
+
+                guiGet { tree.isExpanded(0) } shouldBe true
+            }
+
+            test("expands the scheme's new parent if the parent changes") {
+                guiRun {
+                    tree.collapseRow(1)
+                    tree.expandRow(0)
+                }
+
+                val scheme = currentList.templates[0].schemes[1]
+                guiRun { tree.moveSchemeByOnePosition(scheme, moveDown = true) }
+
+                tree.myModel.root.descendants[2].children shouldContain StateNode(scheme)
+                guiGet { tree.isExpanded(2) } shouldBe true
+            }
         }
     }
 
@@ -464,23 +614,25 @@ object TemplateJTreeTest : FunSpec({
         @Suppress("BooleanLiteralArgument") // Argument names are clear from lambda later on
         withData(
             mapOf<String, Row3<() -> Scheme, Boolean, Boolean>>(
-                "first template" to row({ tree.myModel.list.templates[0] }, false, false),
-                "first scheme" to row({ tree.myModel.list.templates[0].schemes[0] }, false, false),
-                "last template" to row({ tree.myModel.list.templates[2] }, true, false),
-                "last scheme" to row({ tree.myModel.list.templates[2].schemes[1] }, true, false),
-                "move scheme within template" to row({ tree.myModel.list.templates[0].schemes[1] }, false, true),
-                "move templates within list" to row({ tree.myModel.list.templates[1] }, true, true),
-                "move scheme between templates" to row({ tree.myModel.list.templates[1].schemes[0] }, true, true),
+                "first template" to row({ currentList.templates[0] }, false, false),
+                "first scheme" to row({ currentList.templates[0].schemes[0] }, false, false),
+                "last template" to row({ currentList.templates[2] }, true, false),
+                "last scheme" to row({ currentList.templates[2].schemes[1] }, true, false),
+                "move scheme within template" to row({ currentList.templates[0].schemes[1] }, false, true),
+                "move templates within list" to row({ currentList.templates[1] }, true, true),
+                "move scheme between templates" to row({ currentList.templates[1].schemes[0] }, true, true),
             )
-        ) { (scheme, moveDown, expected) -> tree.canMoveSchemeByOnePosition(scheme(), moveDown) shouldBe expected }
+        ) { (scheme, moveDown, expected) ->
+            guiRun { tree.expandNodes() }
+
+            tree.canMoveSchemeByOnePosition(scheme(), moveDown) shouldBe expected
+        }
     }
 
 
     context("buttons") {
-        lateinit var frame: FrameFixture
-
-
         beforeNonContainer {
+            frame.cleanUp()
             frame = showInFrame(guiGet { tree.asDecoratedPanel() })
         }
 
@@ -507,11 +659,14 @@ object TemplateJTreeTest : FunSpec({
             }
 
             test("removes the selected scheme") {
-                guiRun { tree.selectedScheme = tree.myModel.list.templates[0].schemes[1] }
+                guiRun {
+                    tree.expandRow(0)
+                    tree.selectedScheme = currentList.templates[0].schemes[1]
+                }
 
                 guiRun { frame.getActionButton("Remove").click() }
 
-                tree.myModel.list.templates[0].schemes.names() shouldContainExactly listOf("Scheme0")
+                currentList.templates[0].schemes.names() shouldContainExactly listOf("Scheme0")
             }
         }
 
@@ -526,38 +681,46 @@ object TemplateJTreeTest : FunSpec({
             }
 
             test("copies the selected scheme") {
-                guiRun { tree.selectedScheme = tree.myModel.list.templates[1].schemes[0] }
+                guiRun {
+                    tree.expandRow(1)
+                    tree.selectedScheme = currentList.templates[1].schemes[0]
+                }
 
                 guiRun { frame.getActionButton("Copy").click() }
 
-                tree.myModel.list.templates[1].schemes.names() shouldContainExactly listOf("Scheme2", "Scheme2")
+                currentList.templates[1].schemes.names() shouldContainExactly listOf("Scheme2", "Scheme2")
             }
 
             test("creates an independent copy of the selected scheme") {
-                guiRun { tree.selectedScheme = tree.myModel.list.templates[2].schemes[1] }
+                guiRun {
+                    tree.expandRow(2)
+                    tree.selectedScheme = currentList.templates[2].schemes[1]
+                }
 
                 guiRun { frame.getActionButton("Copy").click() }
-                (tree.myModel.list.templates[2].schemes[2] as DummyScheme).name = "New Name"
+                (currentList.templates[2].schemes[2] as DummyScheme).name = "New Name"
 
-                tree.myModel.list.templates[2].schemes[1].name shouldNotBe "New Name"
+                currentList.templates[2].schemes.names() shouldContainExactly listOf("Scheme3", "Scheme4", "New Name")
             }
 
             test("ensures the copy uses the same settings state") {
                 // Arrange
-                val referencedTemplate = tree.myModel.list.templates[0]
+                val referencedTemplate = currentList.templates[0]
                 val referencingScheme = TemplateReference(referencedTemplate.uuid)
                 val referencingTemplate = Template(schemes = mutableListOf(referencingScheme))
-                    .also { it.applyContext(currentSettings) }
+                    .also { it.applyContext(currentList.context) }
 
-                currentSettings.templates += referencingTemplate
-                currentSettings.applyContext(currentSettings)
+                currentList.templates += referencingTemplate
 
-                guiRun { tree.reload() }
-                tree.myModel.list.templates.last() shouldBe referencingTemplate
+                guiRun {
+                    tree.reload()
+                    tree.expandRow(3)
+                }
+                currentList.templates[3] shouldBe referencingTemplate
 
                 // Act
                 guiRun {
-                    tree.selectedScheme = tree.myModel.list.templates[3].schemes[0]
+                    tree.selectedScheme = currentList.templates[3].schemes[0]
                     frame.getActionButton("Copy").click()
                 }
 
@@ -581,7 +744,7 @@ object TemplateJTreeTest : FunSpec({
 
             test("is disabled if the selected scheme cannot be moved up") {
                 guiRun {
-                    tree.selectedScheme = tree.myModel.list.templates[0]
+                    tree.selectedScheme = currentList.templates[0]
                     updateButtons()
                 }
 
@@ -590,7 +753,7 @@ object TemplateJTreeTest : FunSpec({
 
             test("is enabled if the selected scheme can be moved up") {
                 guiRun {
-                    tree.selectedScheme = tree.myModel.list.templates[1]
+                    tree.selectedScheme = currentList.templates[1]
                     updateButtons()
                 }
 
@@ -598,11 +761,14 @@ object TemplateJTreeTest : FunSpec({
             }
 
             test("moves the selected scheme up") {
-                guiRun { tree.selectedScheme = tree.myModel.list.templates[0].schemes[1] }
+                guiRun {
+                    tree.expandRow(0)
+                    tree.selectedScheme = currentList.templates[0].schemes[1]
+                }
 
                 guiRun { frame.getActionButton("Up").click() }
 
-                tree.myModel.list.templates[0].schemes.names() shouldContainExactly listOf("Scheme1", "Scheme0")
+                currentList.templates[0].schemes.names() shouldContainExactly listOf("Scheme1", "Scheme0")
             }
         }
 
@@ -618,7 +784,7 @@ object TemplateJTreeTest : FunSpec({
 
             test("is disabled if the selected scheme cannot be moved down") {
                 guiRun {
-                    tree.selectedScheme = tree.myModel.list.templates[2]
+                    tree.selectedScheme = currentList.templates[2]
                     updateButtons()
                 }
 
@@ -627,7 +793,7 @@ object TemplateJTreeTest : FunSpec({
 
             test("is enabled if the selected scheme can be moved down") {
                 guiRun {
-                    tree.selectedScheme = tree.myModel.list.templates[1]
+                    tree.selectedScheme = currentList.templates[1]
                     updateButtons()
                 }
 
@@ -635,11 +801,14 @@ object TemplateJTreeTest : FunSpec({
             }
 
             test("moves the selected scheme down") {
-                guiRun { tree.selectedScheme = tree.myModel.list.templates[2].schemes[0] }
+                guiRun {
+                    tree.expandRow(2)
+                    tree.selectedScheme = currentList.templates[2].schemes[0]
+                }
 
                 guiRun { frame.getActionButton("Down").click() }
 
-                tree.myModel.list.templates[2].schemes.names() shouldContainExactly listOf("Scheme4", "Scheme3")
+                currentList.templates[2].schemes.names() shouldContainExactly listOf("Scheme4", "Scheme3")
             }
         }
 
@@ -655,7 +824,7 @@ object TemplateJTreeTest : FunSpec({
 
             test("is disabled if the selection has not been modified") {
                 guiRun {
-                    tree.selectedScheme = tree.myModel.list.templates[0]
+                    tree.selectedScheme = currentList.templates[0]
                     updateButtons()
                 }
 
@@ -664,7 +833,7 @@ object TemplateJTreeTest : FunSpec({
 
             test("removes the scheme if it was newly added") {
                 val template = Template("New Template")
-                tree.myModel.list.templates += template
+                currentList.templates += template
                 guiRun { tree.reload() }
 
                 guiRun {
@@ -672,64 +841,69 @@ object TemplateJTreeTest : FunSpec({
                     frame.getActionButton("Reset").click()
                 }
 
-                tree.myModel.list.templates.names() shouldNotContain "New Template"
+                currentList.templates.names() shouldNotContain "New Template"
             }
 
             test("resets changes to the initially selected scheme") {
-                (tree.myModel.list.templates[0].schemes[0] as DummyScheme).name = "New Name"
+                (currentList.templates[0].schemes[0] as DummyScheme).name = "New Name"
                 guiRun { tree.reload() }
+                currentList.templates[0].schemes[0].name shouldBe "New Name"
 
                 guiRun { frame.getActionButton("Reset").click() }
 
-                (tree.myModel.list.templates[0].schemes[0] as DummyScheme).name shouldBe "Scheme0"
+                currentList.templates[0].schemes[0].name shouldBe "Scheme0"
             }
 
             test("resets changes to a template") {
-                tree.myModel.list.templates[0].name = "New Name"
+                currentList.templates[0].name = "New Name"
                 guiRun { tree.reload() }
+                currentList.templates[0].name shouldBe "New Name"
 
                 guiRun {
-                    tree.selectedScheme = tree.myModel.list.templates[0]
+                    tree.selectedScheme = currentList.templates[0]
                     frame.getActionButton("Reset").click()
                 }
 
-                tree.myModel.list.templates[0].name shouldBe "Template0"
+                currentList.templates[0].name shouldBe "Template0"
             }
 
-            test("resets changes to a scheme") {
-                (tree.myModel.list.templates[1].schemes[0] as DummyScheme).name = "New Name"
+            test("resets changes to the selected scheme") {
+                (currentList.templates[1].schemes[0] as DummyScheme).name = "New Name"
                 guiRun { tree.reload() }
+                currentList.templates[1].schemes[0].name shouldBe "New Name"
 
                 guiRun {
-                    tree.selectedScheme = tree.myModel.list.templates[1].schemes[0]
+                    tree.selectedScheme = currentList.templates[1].schemes[0]
                     frame.getActionButton("Reset").click()
                 }
 
-                tree.myModel.list.templates[1].schemes[0].name shouldBe "Scheme2"
+                currentList.templates[1].schemes[0].name shouldBe "Scheme2"
             }
 
-            test("resets a template's scheme order") {
-                tree.myModel.list.templates[0].schemes.setAll(tree.myModel.list.templates[0].schemes.reversed())
+            test("resets the selected template's scheme order") {
+                currentList.templates[0].schemes.setAll(currentList.templates[0].schemes.reversed())
                 guiRun { tree.reload() }
+                currentList.templates[0].schemes.names() shouldContainExactly listOf("Scheme1", "Scheme0")
 
                 guiRun {
-                    tree.selectedScheme = tree.myModel.list.templates[0]
+                    tree.selectedScheme = currentList.templates[0]
                     frame.getActionButton("Reset").click()
                 }
 
-                tree.myModel.list.templates[0].schemes.names() shouldContainExactly listOf("Scheme0", "Scheme1")
+                currentList.templates[0].schemes.names() shouldContainExactly listOf("Scheme0", "Scheme1")
             }
 
-            test("resets a template's schemes") {
-                (tree.myModel.list.templates[2].schemes[0] as DummyScheme).name = "New Name"
+            test("resets the selected template's schemes") {
+                (currentList.templates[2].schemes[0] as DummyScheme).name = "New Name"
                 guiRun { tree.reload() }
+                currentList.templates[2].schemes[0].name shouldBe "New Name"
 
                 guiRun {
-                    tree.selectedScheme = tree.myModel.list.templates[2]
+                    tree.selectedScheme = currentList.templates[2]
                     frame.getActionButton("Reset").click()
                 }
 
-                tree.myModel.list.templates[2].schemes[0].name shouldBe "Scheme3"
+                currentList.templates[2].schemes[0].name shouldBe "Scheme3"
             }
         }
     }
diff --git a/src/test/kotlin/com/fwdekker/randomness/template/TemplateListEditorTest.kt b/src/test/kotlin/com/fwdekker/randomness/template/TemplateListEditorTest.kt
index 9c8427591..c62eaac91 100644
--- a/src/test/kotlin/com/fwdekker/randomness/template/TemplateListEditorTest.kt
+++ b/src/test/kotlin/com/fwdekker/randomness/template/TemplateListEditorTest.kt
@@ -12,9 +12,11 @@ import com.fwdekker.randomness.testhelpers.afterNonContainer
 import com.fwdekker.randomness.testhelpers.beforeNonContainer
 import com.fwdekker.randomness.testhelpers.guiGet
 import com.fwdekker.randomness.testhelpers.guiRun
+import com.fwdekker.randomness.testhelpers.matchBundle
 import com.fwdekker.randomness.testhelpers.shouldContainExactly
 import com.fwdekker.randomness.uuid.UuidScheme
 import com.fwdekker.randomness.word.WordScheme
+import com.intellij.openapi.util.Disposer
 import com.intellij.testFramework.fixtures.IdeaTestFixture
 import com.intellij.testFramework.fixtures.IdeaTestFixtureFactory
 import com.intellij.ui.JBSplitter
@@ -24,6 +26,7 @@ import io.kotest.core.spec.style.FunSpec
 import io.kotest.data.Row2
 import io.kotest.data.row
 import io.kotest.datatest.withData
+import io.kotest.matchers.should
 import io.kotest.matchers.shouldBe
 import org.assertj.swing.edt.FailOnThreadViolationRepaintManager
 import org.assertj.swing.fixture.AbstractComponentFixture
@@ -41,7 +44,7 @@ object TemplateListEditorTest : FunSpec({
     lateinit var ideaFixture: IdeaTestFixture
     lateinit var frame: FrameFixture
 
-    lateinit var context: Settings
+    lateinit var templateList: TemplateList
     lateinit var editor: TemplateListEditor
 
 
@@ -56,23 +59,22 @@ object TemplateListEditorTest : FunSpec({
         ideaFixture = IdeaTestFixtureFactory.getFixtureFactory().createBareFixture()
         ideaFixture.setUp()
 
-        context = Settings(
-            templateList = TemplateList(
+        templateList =
+            TemplateList(
                 mutableListOf(
                     Template("Template1", mutableListOf(IntegerScheme(), StringScheme())),
                     Template("Template2", mutableListOf(DecimalScheme(), WordScheme())),
                 )
-            ),
-        )
-        context.templateList.applyContext(context)
+            )
+        templateList.applyContext(Settings(templateList = templateList))
 
-        editor = guiGet { TemplateListEditor(context) }
+        editor = guiGet { TemplateListEditor(templateList) }
         frame = Containers.showInFrame(editor.rootComponent)
     }
 
     afterNonContainer {
         frame.cleanUp()
-        guiRun { editor.dispose() }
+        guiRun { Disposer.dispose(editor) }
         ideaFixture.tearDown()
     }
 
@@ -90,8 +92,8 @@ object TemplateListEditorTest : FunSpec({
                     "template reference" to row(TemplateReference()) { it.comboBox("template") },
                 )
             ) { (scheme, matcher): Row2<Scheme, (FrameFixture) -> AbstractComponentFixture<*, *, *>> ->
-                context.templates.setAll(listOf(Template(schemes = mutableListOf(scheme))))
-                context.templateList.applyContext(context)
+                templateList.templates.setAll(listOf(Template(schemes = mutableListOf(scheme))))
+                templateList.applyContext(templateList.context)
 
                 guiRun {
                     editor.reset()
@@ -103,8 +105,8 @@ object TemplateListEditorTest : FunSpec({
         }
 
         test("loads an editor for templates") {
-            context.templates.setAll(listOf(Template(schemes = mutableListOf())))
-            context.templateList.applyContext(context)
+            templateList.templates.setAll(listOf(Template(schemes = mutableListOf())))
+            templateList.applyContext(templateList.context)
 
             guiRun { editor.reset() }
 
@@ -112,15 +114,13 @@ object TemplateListEditorTest : FunSpec({
         }
 
         test("throws an error for unknown scheme types") {
-            context.templates.setAll(listOf(Template(schemes = mutableListOf(DummyScheme()))))
-            context.templateList.applyContext(context)
+            templateList.templates.setAll(listOf(Template(schemes = mutableListOf(DummyScheme()))))
+            templateList.applyContext(templateList.context)
 
-            shouldThrow<IllegalStateException> {
-                guiRun {
-                    editor.reset()
-                    frame.tree().target().setSelectionRow(1)
-                }
-            }.message shouldBe "Unknown scheme type 'com.fwdekker.randomness.testhelpers.DummyScheme'."
+            guiRun { editor.reset() }
+
+            shouldThrow<IllegalStateException> { guiRun { frame.tree().target().setSelectionRow(1) } }
+                .message should matchBundle("template_list.error.unknown_scheme_type")
         }
     }
 
@@ -164,19 +164,19 @@ object TemplateListEditorTest : FunSpec({
                 frame.tree().target().selectionRows!! shouldContainExactly arrayOf(1)
             }
 
-            test("resets the existing selection if the indicated scheme could not be found") {
+            test("clears the existing selection if the indicated scheme could not be found") {
                 guiRun { frame.tree().target().selectionRows = intArrayOf(3) }
 
                 editor.queueSelection = "231ee9da-8f72-4535-b770-0119fdf68f70"
                 guiRun { editor.reset() }
 
-                frame.tree().target().selectionRows!! shouldContainExactly arrayOf(0)
+                frame.tree().target().selectionCount shouldBe 0
             }
 
             test("selects the indicated template") {
                 guiRun { frame.tree().target().selectionRows = intArrayOf(4) }
 
-                editor.queueSelection = context.templates[1].uuid
+                editor.queueSelection = templateList.templates[1].uuid
                 guiRun { editor.reset() }
 
                 frame.tree().target().selectionRows!! shouldContainExactly arrayOf(3)
@@ -185,7 +185,7 @@ object TemplateListEditorTest : FunSpec({
             test("selects the indicated scheme") {
                 guiRun { frame.tree().target().selectionRows = intArrayOf(2) }
 
-                editor.queueSelection = context.templates[1].schemes[0].uuid
+                editor.queueSelection = templateList.templates[1].schemes[0].uuid
                 guiRun { editor.reset() }
 
                 frame.tree().target().selectionRows!! shouldContainExactly arrayOf(4)
diff --git a/src/test/kotlin/com/fwdekker/randomness/testhelpers/Dummies.kt b/src/test/kotlin/com/fwdekker/randomness/testhelpers/Dummies.kt
index efc2ca8ae..c8f3c2c1c 100644
--- a/src/test/kotlin/com/fwdekker/randomness/testhelpers/Dummies.kt
+++ b/src/test/kotlin/com/fwdekker/randomness/testhelpers/Dummies.kt
@@ -18,7 +18,7 @@ import kotlin.random.Random
 /**
  * A simple [State] with a single mutable [list].
  */
-data class DummyState(var list: MutableList<Int> = mutableListOf()) : State() {
+data class DummyState(val list: MutableList<Int> = mutableListOf()) : State() {
     override fun deepCopy(retainUuid: Boolean) =
         copy(list = list.toMutableList()).deepCopyTransient(retainUuid)
 }
diff --git a/src/test/kotlin/com/fwdekker/randomness/ui/PreviewPanelTest.kt b/src/test/kotlin/com/fwdekker/randomness/ui/PreviewPanelTest.kt
index bf75c8c3e..37e36d6b4 100644
--- a/src/test/kotlin/com/fwdekker/randomness/ui/PreviewPanelTest.kt
+++ b/src/test/kotlin/com/fwdekker/randomness/ui/PreviewPanelTest.kt
@@ -8,6 +8,7 @@ import com.fwdekker.randomness.testhelpers.find
 import com.fwdekker.randomness.testhelpers.guiGet
 import com.fwdekker.randomness.testhelpers.guiRun
 import com.fwdekker.randomness.testhelpers.matcher
+import com.intellij.openapi.util.Disposer
 import com.intellij.testFramework.fixtures.IdeaTestFixture
 import com.intellij.testFramework.fixtures.IdeaTestFixtureFactory
 import com.intellij.ui.InplaceButton
@@ -51,7 +52,7 @@ object PreviewPanelTest : FunSpec({
 
     afterNonContainer {
         frame.cleanUp()
-        guiRun { panel.dispose() }
+        guiRun { Disposer.dispose(panel) }
         ideaFixture.tearDown()
     }
 
diff --git a/src/test/kotlin/com/fwdekker/randomness/word/WordSchemeEditorTest.kt b/src/test/kotlin/com/fwdekker/randomness/word/WordSchemeEditorTest.kt
index 1822b7d31..72e5ef568 100644
--- a/src/test/kotlin/com/fwdekker/randomness/word/WordSchemeEditorTest.kt
+++ b/src/test/kotlin/com/fwdekker/randomness/word/WordSchemeEditorTest.kt
@@ -15,6 +15,7 @@ import com.fwdekker.randomness.testhelpers.textProp
 import com.fwdekker.randomness.testhelpers.valueProp
 import com.intellij.openapi.application.runWriteAction
 import com.intellij.openapi.editor.impl.EditorComponentImpl
+import com.intellij.openapi.util.Disposer
 import com.intellij.testFramework.fixtures.IdeaTestFixture
 import com.intellij.testFramework.fixtures.IdeaTestFixtureFactory
 import io.kotest.core.NamedTag
@@ -59,7 +60,7 @@ object WordSchemeEditorTest : FunSpec({
 
     afterNonContainer {
         frame.cleanUp()
-        guiRun { editor.dispose() }
+        guiRun { Disposer.dispose(editor) }
         ideaFixture.tearDown()
     }