gui: forms editor - rules and excludes as forms, with add, delete and move

3 files changed, 810 insertions, 3 deletions

diff --git a/gui/internal/ui/forms.go b/gui/internal/ui/forms.go
new file mode 100644
index 0000000..928c17e
--- /dev/null
+++ b/gui/internal/ui/forms.go
@@ -0,0 +1,753 @@
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+package ui
+
+import (
+	"fmt"
+	"strings"
+
+	"github.com/diamondburned/gotk4/pkg/glib/v2"
+	"github.com/diamondburned/gotk4/pkg/gtk/v4"
+
+	"krino/gui/internal/model"
+	"krino/internal/config"
+	"krino/internal/sexp"
+)
+
+// condKinds are the tests a condition row offers, plus the three operators
+// that hold other conditions. A row's entry holds that form's arguments
+// exactly as they are written, so no test is out of reach of the form
+// editor and none is silently rewritten (see docs/gui-design.md §5.1 and
+// the deviation noted in plan 17).
+var condKinds = []string{"type", "name", "path", "content", "size", "age",
+	"duplicate", "matched", "and", "or", "not"}
+
+// condHints is the example shown beside a row, by kind.
+var condHints = map[string]string{
+	"type":      `pdf doc  (extensions or a group)`,
+	"name":      `"^faktura" "^fv"  (regexes, any may match)`,
+	"path":      `"work/"  (regex against the path under the root)`,
+	"content":   `"invoice" "faktura"  (keywords, any may match)`,
+	"size":      `> 10M`,
+	"age":       `> 90d`,
+	"duplicate": `"~/docs"  (or empty: the directory's own tree)`,
+	"matched":   `(no arguments)`,
+	"and":       `(type pdf) (content "invoice")`,
+	"or":        `(type doc) (type docx)`,
+	"not":       `(duplicate)`,
+}
+
+// actionKinds are the actions a rule can carry, in the order the form
+// offers them.
+var actionKinds = []string{"copy", "move", "rename", "delete", "delete permanent"}
+
+// formsView is the Forms half of the Rules tab: the directory's excludes
+// and rules on the left, the selected one as a form in the middle.
+type formsView struct {
+	w     *Window
+	owner *rulesView
+	root  *gtk.Box
+
+	list                 *gtk.ListBox
+	add, del, up, down   *gtk.Button
+	place                *gtk.Box
+	note                 *gtk.Label
+	forms                []model.Form
+	sel                  int
+	editor               *formEditor
+	pending              glib.SourceHandle
+	quiet                bool
+	commentsAcknowledged map[string]bool
+}
+
+func newFormsView(w *Window, owner *rulesView) *formsView {
+	f := &formsView{w: w, owner: owner, sel: -1, commentsAcknowledged: map[string]bool{}}
+	f.root = gtk.NewBox(gtk.OrientationHorizontal, 0)
+
+	f.list = gtk.NewListBox()
+	f.list.SetSelectionMode(gtk.SelectionSingle)
+	listScroll := gtk.NewScrolledWindow()
+	listScroll.SetChild(f.list)
+	listScroll.SetVExpand(true)
+
+	f.add = gtk.NewButtonWithLabel("Add rule")
+	f.del = gtk.NewButtonWithLabel("Delete")
+	f.up = gtk.NewButtonWithLabel("Up")
+	f.down = gtk.NewButtonWithLabel("Down")
+	buttons := gtk.NewBox(gtk.OrientationHorizontal, 4)
+	buttons.SetMarginStart(6)
+	buttons.SetMarginEnd(6)
+	buttons.SetMarginTop(4)
+	buttons.SetMarginBottom(4)
+	for _, b := range []*gtk.Button{f.add, f.del, f.up, f.down} {
+		buttons.Append(b)
+	}
+
+	left := gtk.NewBox(gtk.OrientationVertical, 0)
+	left.Append(listScroll)
+	left.Append(gtk.NewSeparator(gtk.OrientationHorizontal))
+	left.Append(buttons)
+	left.SetSizeRequest(260, -1)
+
+	f.note = gtk.NewLabel("")
+	f.note.SetXAlign(0)
+	f.note.SetWrap(true)
+	f.note.SetMarginStart(8)
+	f.note.SetMarginEnd(8)
+	f.note.SetMarginTop(6)
+	f.place = gtk.NewBox(gtk.OrientationVertical, 0)
+	f.place.SetVExpand(true)
+	placeScroll := gtk.NewScrolledWindow()
+	placeScroll.SetChild(f.place)
+	placeScroll.SetVExpand(true)
+	placeScroll.SetHExpand(true)
+	right := gtk.NewBox(gtk.OrientationVertical, 0)
+	right.Append(f.note)
+	right.Append(placeScroll)
+
+	f.root.Append(left)
+	f.root.Append(gtk.NewSeparator(gtk.OrientationVertical))
+	f.root.Append(right)
+
+	f.list.ConnectRowSelected(func(row *gtk.ListBoxRow) {
+		if row != nil && !f.quiet {
+			f.show(row.Index())
+		}
+	})
+	f.add.ConnectClicked(f.onAdd)
+	f.del.ConnectClicked(f.onDelete)
+	f.up.ConnectClicked(func() { f.move(-1) })
+	f.down.ConnectClicked(func() { f.move(1) })
+	return f
+}
+
+// reload re-reads the text in the editor and rebuilds the list. Text that
+// does not parse has no forms: the caller keeps the Text tab (GUI design
+// §5.2).
+func (f *formsView) reload() error {
+	forms, err := f.owner.formsOf()
+	if err != nil {
+		return err
+	}
+	f.forms = forms
+	keep := f.sel
+	f.quiet = true
+	clearList(f.list)
+	for _, form := range forms {
+		row := gtk.NewListBoxRow()
+		label := gtk.NewLabel(escape(formLabel(form)))
+		label.SetXAlign(0)
+		label.SetMarginStart(6)
+		label.SetMarginEnd(6)
+		label.SetMarginTop(2)
+		label.SetMarginBottom(2)
+		label.SetEllipsize(3) // end
+		label.SetMaxWidthChars(30)
+		label.SetTooltipText(escape(form.Label))
+		row.SetChild(label)
+		f.list.Append(row)
+	}
+	f.quiet = false
+	if keep >= 0 && keep < len(forms) {
+		f.list.SelectRow(f.list.RowAtIndex(keep))
+		f.show(keep)
+	} else {
+		f.sel = -1
+		f.clearEditor("Select a rule to edit it, or Add rule.")
+	}
+	return nil
+}
+
+// formLabel is one line of the list: what the form is, and what it does.
+func formLabel(f model.Form) string {
+	if f.Kind == model.ExcludeForm {
+		return "exclude: " + f.Label
+	}
+	var what []string
+	for _, a := range f.Rule.Actions {
+		what = append(what, a.Kind.String())
+	}
+	if len(what) == 0 {
+		return f.Label
+	}
+	return f.Label + "  (" + strings.Join(what, ", ") + ")"
+}
+
+// show builds the editor for form i.
+func (f *formsView) show(i int) {
+	if i < 0 || i >= len(f.forms) {
+		return
+	}
+	f.sel = i
+	form := f.forms[i]
+	f.note.SetText("")
+	if has, err := f.owner.rules.FormHasComments(i); err == nil && has {
+		f.note.SetText("This form has comments inside it. The form editor writes it back from what krino parsed, so those comments would be dropped - the Text tab keeps them.")
+	}
+	f.editor = newFormEditor(form, f.armApply)
+	if child := f.place.FirstChild(); child != nil {
+		f.place.Remove(child)
+	}
+	f.place.Append(f.editor.root)
+}
+
+// clearEditor empties the middle pane.
+func (f *formsView) clearEditor(text string) {
+	f.editor = nil
+	if child := f.place.FirstChild(); child != nil {
+		f.place.Remove(child)
+	}
+	f.note.SetText(text)
+}
+
+// armApply writes the form back after a pause, so typing in a field does
+// not rewrite the file on every keystroke.
+func (f *formsView) armApply() {
+	if f.pending != 0 {
+		glib.SourceRemove(f.pending)
+	}
+	f.pending = glib.TimeoutAdd(checkDelay, func() bool {
+		f.pending = 0
+		f.apply()
+		return false
+	})
+}
+
+// apply replaces the selected form's text with what the editor holds.
+func (f *formsView) apply() {
+	if f.editor == nil || f.sel < 0 {
+		return
+	}
+	text, err := f.editor.text()
+	if err != nil {
+		f.owner.setCheck("form: " + err.Error())
+		return
+	}
+	if !f.confirmComments() {
+		return
+	}
+	if err := f.owner.rules.ReplaceForm(f.sel, text); err != nil {
+		f.owner.setCheck("form: " + err.Error())
+		return
+	}
+	f.owner.textChangedByForm()
+	f.refreshLabels()
+}
+
+// confirmComments asks once per form before an edit drops the comments
+// inside it (GUI design §5.1).
+func (f *formsView) confirmComments() bool {
+	has, err := f.owner.rules.FormHasComments(f.sel)
+	if err != nil || !has {
+		return true
+	}
+	key := fmt.Sprintf("%d:%s", f.sel, f.forms[f.sel].Label)
+	if f.commentsAcknowledged[key] {
+		return true
+	}
+	d := gtk.NewMessageDialog(&f.w.win.Window, gtk.DialogModal|gtk.DialogDestroyWithParent,
+		gtk.MessageWarning, gtk.ButtonsNone)
+	d.SetObjectProperty("text", "This form has comments inside it")
+	d.SetObjectProperty("secondary-text",
+		"Editing it here writes it back from what krino parsed, which drops those comments. The Text tab keeps them.")
+	d.AddButton("Go to the Text tab", int(gtk.ResponseCancel))
+	d.AddButton("Edit here anyway", int(gtk.ResponseAccept))
+	d.ConnectResponse(func(response int) {
+		d.Destroy()
+		if response == int(gtk.ResponseAccept) {
+			f.commentsAcknowledged[key] = true
+			f.apply()
+			return
+		}
+		f.owner.showText()
+	})
+	d.Show()
+	return false
+}
+
+// refreshLabels re-reads the forms so the list shows what the edit did,
+// keeping the selection.
+func (f *formsView) refreshLabels() {
+	forms, err := f.owner.formsOf()
+	if err != nil || len(forms) != len(f.forms) {
+		return
+	}
+	f.forms = forms
+	for i, form := range forms {
+		if row := f.list.RowAtIndex(i); row != nil {
+			if label, ok := row.Child().(*gtk.Label); ok {
+				label.SetText(escape(formLabel(form)))
+			}
+		}
+	}
+}
+
+// onAdd puts a new rule after the selected one and opens it.
+func (f *formsView) onAdd() {
+	name := "new rule"
+	for i := 2; f.nameTaken(name); i++ {
+		name = fmt.Sprintf("new rule %d", i)
+	}
+	i, err := f.owner.rules.AddRuleAfter(f.sel, name)
+	if err != nil {
+		f.owner.setCheck("add: " + err.Error())
+		return
+	}
+	f.owner.textChangedByForm()
+	f.sel = i
+	if err := f.reload(); err != nil {
+		f.owner.setCheck("add: " + err.Error())
+	}
+}
+
+// nameTaken reports whether a rule of that name is already in the file.
+func (f *formsView) nameTaken(name string) bool {
+	for _, form := range f.forms {
+		if form.Kind == model.RuleForm && form.Label == name {
+			return true
+		}
+	}
+	return false
+}
+
+// onDelete removes the selected form, after asking.
+func (f *formsView) onDelete() {
+	if f.sel < 0 || f.sel >= len(f.forms) {
+		return
+	}
+	form := f.forms[f.sel]
+	d := gtk.NewMessageDialog(&f.w.win.Window, gtk.DialogModal|gtk.DialogDestroyWithParent,
+		gtk.MessageQuestion, gtk.ButtonsNone)
+	d.SetObjectProperty("text", "Delete "+escape(formLabel(form))+"?")
+	d.SetObjectProperty("secondary-text",
+		"It goes from the text in the editor, with the comment lines directly above it. Nothing is written until you press Save.")
+	d.AddButton("Cancel", int(gtk.ResponseCancel))
+	del := d.AddButton("Delete", int(gtk.ResponseAccept))
+	if b, ok := del.(*gtk.Button); ok {
+		b.AddCSSClass("destructive-action")
+	}
+	d.ConnectResponse(func(response int) {
+		d.Destroy()
+		if response != int(gtk.ResponseAccept) {
+			return
+		}
+		if err := f.owner.rules.DeleteForm(f.sel); err != nil {
+			f.owner.setCheck("delete: " + err.Error())
+			return
+		}
+		f.owner.textChangedByForm()
+		if f.sel >= len(f.forms)-1 {
+			f.sel = len(f.forms) - 2
+		}
+		if err := f.reload(); err != nil {
+			f.owner.setCheck("delete: " + err.Error())
+		}
+	})
+	d.Show()
+}
+
+// move shifts the selected form one place up or down, with its comments.
+func (f *formsView) move(delta int) {
+	if f.sel < 0 {
+		return
+	}
+	to := f.sel + delta
+	if to < 0 || to >= len(f.forms) {
+		return
+	}
+	if err := f.owner.rules.MoveForm(f.sel, delta); err != nil {
+		f.owner.setCheck("move: " + err.Error())
+		return
+	}
+	f.owner.textChangedByForm()
+	f.sel = to
+	if err := f.reload(); err != nil {
+		f.owner.setCheck("move: " + err.Error())
+	}
+}
+
+// formEditor is the widgets of one form, and can write it back.
+type formEditor struct {
+	kind    model.FormKind
+	root    *gtk.Box
+	name    *gtk.Entry
+	conds   *gtk.Box
+	rows    []*condRow
+	acts    *gtk.Box
+	arows   []*actionRow
+	stop    *gtk.CheckButton
+	cse     *gtk.DropDown
+	fold    *gtk.DropDown
+	onConf  *gtk.DropDown
+	changed func()
+}
+
+func newFormEditor(form model.Form, changed func()) *formEditor {
+	fe := &formEditor{kind: form.Kind, changed: changed}
+	fe.root = gtk.NewBox(gtk.OrientationVertical, 6)
+	fe.root.SetMarginStart(8)
+	fe.root.SetMarginEnd(8)
+	fe.root.SetMarginTop(6)
+	fe.root.SetMarginBottom(6)
+
+	if form.Kind == model.RuleForm {
+		fe.name = gtk.NewEntry()
+		fe.name.SetText(form.Rule.Name)
+		fe.name.SetHExpand(true)
+		fe.name.ConnectChanged(func() { changed() })
+		fe.root.Append(field("Name", fe.name))
+	}
+
+	fe.conds = gtk.NewBox(gtk.OrientationVertical, 4)
+	fe.root.Append(heading("Conditions - all of these must hold"))
+	fe.root.Append(fe.conds)
+	addCond := gtk.NewButtonWithLabel("+ test")
+	addCond.ConnectClicked(func() {
+		fe.addCond(nil)
+		changed()
+	})
+	fe.root.Append(leftAligned(addCond))
+
+	when := form.Rule.When
+	if form.Kind == model.ExcludeForm {
+		when = form.Exclude.When
+	} else if !form.Rule.HasWhen {
+		when = nil
+	}
+	for _, c := range when {
+		fe.addCond(c)
+	}
+
+	if form.Kind == model.RuleForm {
+		fe.acts = gtk.NewBox(gtk.OrientationVertical, 4)
+		fe.root.Append(heading("Actions - in order"))
+		fe.root.Append(fe.acts)
+		addAct := gtk.NewButtonWithLabel("+ action")
+		addAct.ConnectClicked(func() {
+			fe.addAction(config.Action{Kind: config.Move})
+			changed()
+		})
+		fe.root.Append(leftAligned(addAct))
+		for _, a := range form.Rule.Actions {
+			fe.addAction(a)
+		}
+
+		fe.stop = gtk.NewCheckButtonWithLabel("(stop) - a file this rule matches takes no later rule")
+		fe.stop.SetActive(form.Rule.Stop)
+		fe.stop.ConnectToggled(func() { changed() })
+		fe.root.Append(fe.stop)
+
+		fe.root.Append(heading("Settings for this rule"))
+		fe.cse = dropDown([]string{"default", "ignore", "strict"}, caseIndex(form.Rule.Settings), changed)
+		fe.fold = dropDown([]string{"default", "yes", "no"}, foldIndex(form.Rule.Settings), changed)
+		fe.onConf = dropDown([]string{"default", "suffix", "skip", "overwrite"}, conflictIndex(form.Rule.Settings), changed)
+		fe.root.Append(field("case", fe.cse))
+		fe.root.Append(field("fold", fe.fold))
+		fe.root.Append(field("on-conflict", fe.onConf))
+	}
+	return fe
+}
+
+// text is the form as the printer writes it, from what the widgets hold.
+func (fe *formEditor) text() (string, error) {
+	var when []*sexp.Node
+	for _, row := range fe.rows {
+		if row.gone {
+			continue
+		}
+		text := row.text()
+		nodes, err := sexp.Parse("form", []byte(text))
+		if err != nil {
+			return "", fmt.Errorf("%s: %v", text, err)
+		}
+		if len(nodes) != 1 {
+			return "", fmt.Errorf("%s is not one condition", text)
+		}
+		when = append(when, nodes[0])
+	}
+	if fe.kind == model.ExcludeForm {
+		if len(when) == 0 {
+			return "", fmt.Errorf("an exclude needs a condition")
+		}
+		return config.PrintExclude(&config.Exclude{When: when}), nil
+	}
+	rule := &config.Rule{
+		Name:    fe.name.Text(),
+		HasWhen: len(when) > 0,
+		When:    when,
+		Stop:    fe.stop.Active(),
+	}
+	for _, row := range fe.arows {
+		if row.gone {
+			continue
+		}
+		rule.Actions = append(rule.Actions, row.action())
+	}
+	rule.Settings = settingsFrom(fe.cse, fe.fold, fe.onConf)
+	return config.PrintRule(rule), nil
+}
+
+// addCond adds a condition row, filled in from n when there is one.
+func (fe *formEditor) addCond(n *sexp.Node) {
+	row := newCondRow(n, fe.changed)
+	fe.rows = append(fe.rows, row)
+	fe.conds.Append(row.root)
+}
+
+// addAction adds an action row.
+func (fe *formEditor) addAction(a config.Action) {
+	row := newActionRow(a, fe.changed)
+	fe.arows = append(fe.arows, row)
+	fe.acts.Append(row.root)
+}
+
+// condRow is one condition: its kind, and its arguments as written.
+type condRow struct {
+	root *gtk.Box
+	kind *gtk.DropDown
+	args *gtk.Entry
+	gone bool
+}
+
+func newCondRow(n *sexp.Node, changed func()) *condRow {
+	c := &condRow{}
+	c.root = gtk.NewBox(gtk.OrientationHorizontal, 6)
+	c.kind = gtk.NewDropDownFromStrings(condKinds)
+	c.args = gtk.NewEntry()
+	c.args.SetHExpand(true)
+	if n != nil {
+		head, args := splitNode(n)
+		if i := indexOf(condKinds, head); i >= 0 {
+			c.kind.SetSelected(uint(i))
+		}
+		c.args.SetText(args)
+	}
+	c.showHint()
+	remove := gtk.NewButtonWithLabel("-")
+	remove.ConnectClicked(func() {
+		c.gone = true
+		c.root.SetVisible(false)
+		changed()
+	})
+	c.kind.Connect("notify::selected", func() {
+		c.showHint()
+		changed()
+	})
+	c.args.ConnectChanged(func() { changed() })
+	c.root.Append(c.kind)
+	c.root.Append(c.args)
+	c.root.Append(remove)
+	return c
+}
+
+// text is the condition as it will be written.
+func (c *condRow) text() string {
+	kind := condKinds[c.kind.Selected()]
+	args := strings.TrimSpace(c.args.Text())
+	if args == "" {
+		return "(" + kind + ")"
+	}
+	return "(" + kind + " " + args + ")"
+}
+
+// showHint puts the example for the chosen kind in the entry, where it
+// shows while the row is empty and as its tooltip once it is not.
+func (c *condRow) showHint() {
+	hint := condHints[condKinds[c.kind.Selected()]]
+	c.args.SetPlaceholderText(hint)
+	c.args.SetTooltipText(hint)
+}
+
+// actionRow is one action: what it does, and its argument.
+type actionRow struct {
+	root *gtk.Box
+	kind *gtk.DropDown
+	arg  *gtk.Entry
+	gone bool
+}
+
+func newActionRow(a config.Action, changed func()) *actionRow {
+	r := &actionRow{}
+	r.root = gtk.NewBox(gtk.OrientationHorizontal, 6)
+	r.kind = gtk.NewDropDownFromStrings(actionKinds)
+	r.kind.SetSelected(uint(actionIndex(a.Kind)))
+	r.arg = gtk.NewEntry()
+	r.arg.SetText(a.Arg)
+	r.arg.SetHExpand(true)
+	r.arg.SetPlaceholderText("Invoices/{mtime:%Y}  - {name} {ext} {1} {mtime:FMT} {now:FMT}")
+	r.setArgSensitive()
+	remove := gtk.NewButtonWithLabel("-")
+	remove.ConnectClicked(func() {
+		r.gone = true
+		r.root.SetVisible(false)
+		changed()
+	})
+	r.kind.Connect("notify::selected", func() {
+		r.setArgSensitive()
+		changed()
+	})
+	r.arg.ConnectChanged(func() { changed() })
+	r.root.Append(r.kind)
+	r.root.Append(r.arg)
+	r.root.Append(remove)
+	return r
+}
+
+// setArgSensitive turns the argument off for the two deletes, which take
+// none.
+func (r *actionRow) setArgSensitive() {
+	kind := actionKinds[r.kind.Selected()]
+	r.arg.SetSensitive(kind != "delete" && kind != "delete permanent")
+}
+
+// action is the action the row holds.
+func (r *actionRow) action() config.Action {
+	switch actionKinds[r.kind.Selected()] {
+	case "copy":
+		return config.Action{Kind: config.Copy, Arg: r.arg.Text()}
+	case "rename":
+		return config.Action{Kind: config.Rename, Arg: r.arg.Text()}
+	case "delete":
+		return config.Action{Kind: config.Delete}
+	case "delete permanent":
+		return config.Action{Kind: config.DeletePermanent}
+	}
+	return config.Action{Kind: config.Move, Arg: r.arg.Text()}
+}
+
+// settingsFrom reads the three rule settings; "default" leaves one out.
+func settingsFrom(cse, fold, onConf *gtk.DropDown) config.Settings {
+	var s config.Settings
+	switch cse.Selected() {
+	case 1:
+		m := config.CaseIgnore
+		s.Case = &m
+	case 2:
+		m := config.CaseStrict
+		s.Case = &m
+	}
+	switch fold.Selected() {
+	case 1:
+		yes := true
+		s.Fold = &yes
+	case 2:
+		no := false
+		s.Fold = &no
+	}
+	switch onConf.Selected() {
+	case 1:
+		c := config.ConflictSuffix
+		s.OnConflict = &c
+	case 2:
+		c := config.ConflictSkip
+		s.OnConflict = &c
+	case 3:
+		c := config.ConflictOverwrite
+		s.OnConflict = &c
+	}
+	return s
+}
+
+func caseIndex(s config.Settings) int {
+	if s.Case == nil {
+		return 0
+	}
+	if *s.Case == config.CaseStrict {
+		return 2
+	}
+	return 1
+}
+
+func foldIndex(s config.Settings) int {
+	if s.Fold == nil {
+		return 0
+	}
+	if *s.Fold {
+		return 1
+	}
+	return 2
+}
+
+func conflictIndex(s config.Settings) int {
+	if s.OnConflict == nil {
+		return 0
+	}
+	switch *s.OnConflict {
+	case config.ConflictSkip:
+		return 2
+	case config.ConflictOverwrite:
+		return 3
+	}
+	return 1
+}
+
+func actionIndex(k config.ActionKind) int {
+	switch k {
+	case config.Copy:
+		return 0
+	case config.Rename:
+		return 2
+	case config.Delete:
+		return 3
+	case config.DeletePermanent:
+		return 4
+	}
+	return 1
+}
+
+// splitNode is a condition's head and the rest of it as written, which is
+// what a row's entry holds.
+func splitNode(n *sexp.Node) (head, args string) {
+	if n.Kind != sexp.List || len(n.Children) == 0 {
+		return "", n.String()
+	}
+	parts := make([]string, 0, len(n.Children)-1)
+	for _, c := range n.Children[1:] {
+		parts = append(parts, c.String())
+	}
+	return n.Head(), strings.Join(parts, " ")
+}
+
+func indexOf(ss []string, s string) int {
+	for i, v := range ss {
+		if v == s {
+			return i
+		}
+	}
+	return -1
+}
+
+// field is a labelled row of the form.
+func field(label string, child gtk.Widgetter) *gtk.Box {
+	box := gtk.NewBox(gtk.OrientationHorizontal, 6)
+	l := gtk.NewLabel(label)
+	l.SetXAlign(0)
+	l.SetSizeRequest(90, -1)
+	box.Append(l)
+	box.Append(child)
+	return box
+}
+
+// heading is a section title inside the form.
+func heading(text string) *gtk.Label {
+	l := gtk.NewLabel(text)
+	l.SetXAlign(0)
+	l.SetMarginTop(6)
+	l.AddCSSClass("heading")
+	return l
+}
+
+// leftAligned keeps a button from stretching across the form.
+func leftAligned(w gtk.Widgetter) *gtk.Box {
+	box := gtk.NewBox(gtk.OrientationHorizontal, 0)
+	box.Append(w)
+	return box
+}
+
+// dropDown is a combo with its starting choice and change handler.
+func dropDown(items []string, selected int, changed func()) *gtk.DropDown {
+	d := gtk.NewDropDownFromStrings(items)
+	d.SetSelected(uint(selected))
+	d.Connect("notify::selected", func() { changed() })
+	return d
+}
diff --git a/gui/internal/ui/rules.go b/gui/internal/ui/rules.go
index 741f6b1..d582f1e 100644
--- a/gui/internal/ui/rules.go
+++ b/gui/internal/ui/rules.go
@@ -42,9 +42,12 @@ type rulesView struct {
 	testGo   *gtk.Button
 	out      *gtk.TextView
 
+	sub     *gtk.Notebook
+	forms   *formsView
 	rules   *model.Rules
 	pending glib.SourceHandle
 	quiet   bool // set while the view is being filled, so no check is armed
+	inSwap  bool // set while a sub-tab switch is being handled
 }
 
 func newRulesView(w *Window) *rulesView {
@@ -131,19 +134,37 @@ func newRulesView(w *Window) *rulesView {
 	right.Append(gtk.NewSeparator(gtk.OrientationHorizontal))
 	right.Append(outScroll)
 
+	// Two ways to edit the same file: forms, and the text itself.
+	r.sub = gtk.NewNotebook()
+	r.forms = newFormsView(w, r)
+	r.sub.AppendPage(r.forms.root, gtk.NewLabel("Forms"))
+	r.sub.AppendPage(left, gtk.NewLabel("Text"))
+
 	panes := gtk.NewPaned(gtk.OrientationHorizontal)
-	panes.SetStartChild(left)
+	panes.SetStartChild(r.sub)
 	panes.SetEndChild(right)
 	panes.SetResizeStartChild(true)
 	panes.SetResizeEndChild(false)
 	panes.SetShrinkEndChild(false)
-	panes.SetPosition(620)
+	panes.SetPosition(820)
 	panes.SetVExpand(true)
 
 	r.root.Append(bar)
 	r.root.Append(gtk.NewSeparator(gtk.OrientationHorizontal))
 	r.root.Append(panes)
 
+	// Switching to Forms re-reads the text; text that does not parse keeps
+	// the Text tab until it is fixed (GUI design §5.2).
+	r.sub.ConnectSwitchPage(func(_ gtk.Widgetter, page uint) {
+		if page != 0 || r.inSwap || r.rules == nil {
+			return
+		}
+		if err := r.forms.reload(); err != nil {
+			r.setCheck("the text does not parse yet: " + err.Error())
+			r.showText()
+		}
+	})
+
 	r.buf.ConnectChanged(r.onChanged)
 	r.diags.ConnectRowSelected(func(row *gtk.ListBoxRow) {
 		if row != nil {
@@ -166,6 +187,34 @@ func newRulesView(w *Window) *rulesView {
 	return r
 }
 
+// formsOf is the forms of the text in the editor, for the Forms sub-tab.
+func (r *rulesView) formsOf() ([]model.Form, error) {
+	if r.rules == nil {
+		return nil, fmt.Errorf("no file is open")
+	}
+	r.rules.SetText(r.text())
+	return r.rules.Forms()
+}
+
+// setCheck writes one line in the bar where the check result goes.
+func (r *rulesView) setCheck(text string) { r.check.SetText(escape(text)) }
+
+// showText brings the Text sub-tab forward.
+func (r *rulesView) showText() {
+	r.inSwap = true
+	r.sub.SetCurrentPage(1)
+	r.inSwap = false
+}
+
+// textChangedByForm puts the model's text - just rewritten by a form edit -
+// in the view, and checks it.
+func (r *rulesView) textChangedByForm() {
+	r.quiet = true
+	r.buf.SetText(r.rules.Text)
+	r.quiet = false
+	r.runCheck()
+}
+
 // selectedName is the directory the picker names, "" when none is offered.
 func (r *rulesView) selectedName() string {
 	i := int(r.dirs.Selected())
@@ -190,6 +239,11 @@ func (r *rulesView) open(name string) {
 	}
 	r.rules = rules
 	r.setEditable(true)
+	defer func() {
+		if err := r.forms.reload(); err != nil {
+			r.forms.clearEditor("the text does not parse yet: " + err.Error())
+		}
+	}()
 	if root := r.w.dirRoot(name); root != "" {
 		r.testPath.SetText(xdg.Abbrev(root) + "/")
 	}
diff --git a/gui/internal/ui/window.go b/gui/internal/ui/window.go
index 2453444..27e1730 100644
--- a/gui/internal/ui/window.go
+++ b/gui/internal/ui/window.go
@@ -38,7 +38,7 @@ func NewWindow(app *gtk.Application, e *engine.Engine) *Window {
 	w := &Window{app: app, engine: e}
 	w.win = gtk.NewApplicationWindow(app)
 	w.win.SetTitle("krino")
-	w.win.SetDefaultSize(1000, 640)
+	w.win.SetDefaultSize(1200, 720)
 
 	notebook := gtk.NewNotebook()
 	w.plan = newPlanView(w)