aboutsummaryrefslogtreecommitdiff
path: root/gui/internal/ui
diff options
context:
space:
mode:
Diffstat (limited to 'gui/internal/ui')
-rw-r--r--gui/internal/ui/forms.go753
-rw-r--r--gui/internal/ui/rules.go58
-rw-r--r--gui/internal/ui/window.go2
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)
generated by cgit v1.3 (git 2.53.0) at 2026-09-19 13:20:24 +0000