StructForm widget for creating modals with a Form

widget/struct_form.go

@@ -0,0 +1,162 @@
+package widget
+
+import (
+	"errors"
+	"fmt"
+	"reflect"
+	"regexp"
+	"strings"
+	"time"
+
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/data/binding"
+	"fyne.io/fyne/v2/widget"
+)
+
+type StructForm struct {
+	widget.BaseWidget
+	structType reflect.Type
+	form       *widget.Form
+	canvas     fyne.Canvas
+	fields     []reflect.StructField
+	widgets    []*widget.FormItem
+	bindings   []binding.DataItem
+	submit     func(s interface{}, err error)
+}
+
+func NewStructForm(s interface{}, submit func(s interface{}, err error), cancel func()) *StructForm {
+	sf := &StructForm{}
+	sf.ExtendBaseWidget(sf)
+
+	sf.structType = reflect.TypeOf(s)
+	sf.fields = parseFields(sf.structType)
+	sf.widgets, sf.bindings = createWidgets(sf.fields)
+	sf.submit = submit
+
+	sf.form = &widget.Form{
+		OnCancel: cancel,
+		OnSubmit: sf.Submit,
+		Items:    sf.widgets,
+	}
+
+	return sf
+}
+
+func buildValue(
+	t reflect.Type,
+	fields []reflect.StructField,
+	bindings []binding.DataItem) (
+	*reflect.Value,
+	error,
+) {
+	val := reflect.New(t)
+
+	for i, f := range fields {
+		var v interface{}
+		var err error
+
+		switch bindings[i].(type) {
+		case binding.Int:
+			v, err = bindings[i].(binding.Int).Get()
+		case binding.String:
+			v, err = bindings[i].(binding.String).Get()
+		case binding.Float:
+			v, err = bindings[i].(binding.Float).Get()
+		case binding.Bool:
+			v, err = bindings[i].(binding.Bool).Get()
+		default:
+			v, err = bindings[i].(binding.Untyped).Get()
+		}
+
+		if err != nil {
+			return nil, err
+		}
+
+		t_s, t_v := val.Elem().FieldByName(f.Name).Type(), reflect.TypeOf(v)
+		if t_s != t_v {
+			return nil, errors.New(fmt.Sprintf("cannot bind mismatched types %v and %v", t_s, t_v))
+		}
+		val.Elem().FieldByName(f.Name).Set(
+			reflect.ValueOf(v),
+		)
+	}
+
+	return &val, nil
+}
+
+func (sf *StructForm) Submit() {
+	s, err := buildValue(
+		sf.structType, sf.fields, sf.bindings,
+	)
+	if err != nil {
+		sf.submit(nil, err)
+	} else {
+		sf.submit(s.Interface(), err)
+	}
+}
+
+func parseFields(t reflect.Type) []reflect.StructField {
+	fields := make([]reflect.StructField, 0)
+	for i := 0; i < t.NumField(); i += 1 {
+		f := t.Field(i)
+		if strings.Contains(f.Tag.Get("fyne"), "field") {
+			fields = append(fields, f)
+		}
+	}
+	return fields
+}
+
+func createWidgets(fs []reflect.StructField) ([]*widget.FormItem, []binding.DataItem) {
+	widgets := make([]*widget.FormItem, len(fs))
+	binding := make([]binding.DataItem, len(fs))
+	matchFirstCap := regexp.MustCompile("(.)([A-Z][a-z]+)")
+	for i, f := range fs {
+		w, b := fieldToWidget(f)
+		widgets[i] = &widget.FormItem{
+			Text:   matchFirstCap.ReplaceAllString(f.Name, "${1} ${2}"),
+			Widget: w,
+		}
+		binding[i] = b
+	}
+	return widgets, binding
+}
+
+func fieldToWidget(f reflect.StructField) (fyne.CanvasObject, binding.DataItem) {
+	switch f.Type.Kind() {
+	case reflect.Float32, reflect.Float64:
+		w := NewNumericalEntry()
+		w.AllowFloat = true
+		b := binding.NewString()
+		w.Bind(b)
+		return w, binding.StringToFloat(b)
+	case reflect.Int:
+		w := NewNumericalEntry()
+		b := binding.NewString()
+		w.Bind(b)
+		return w, binding.StringToInt(b)
+	case reflect.Bool:
+		b := binding.NewBool()
+		w := widget.NewCheck("", func(v bool) {
+			b.Set(v)
+		})
+		return w, b
+	case reflect.TypeOf(time.Time{}).Kind():
+		b := binding.NewUntyped()
+		if err := b.Set(time.Now()); err != nil {
+			panic(err)
+		}
+		w := NewCalendar(time.Now(), func(t time.Time) {
+			b.Set(t)
+		})
+		return w, b
+	default:
+		w := widget.NewEntry()
+		b := binding.NewString()
+		w.Bind(b)
+		return w, b
+	}
+}
+
+func (sf *StructForm) CreateRenderer() fyne.WidgetRenderer {
+	return widget.NewSimpleRenderer(sf.form)
+}

widget/struct_form_test.go

@@ -0,0 +1,179 @@
+package widget
+
+import (
+	"reflect"
+	"testing"
+	"time"
+
+	"fyne.io/fyne/v2/data/binding"
+	"fyne.io/fyne/v2/widget"
+)
+
+type testFoo struct {
+	Field1 string `fyne:"field"`
+	Field2 int
+	Field3 bool      `fyne:"field"`
+	Field4 time.Time `fyne:"field"`
+}
+
+type testBar struct {
+	Field1 float64 `fyne:"field"`
+	Field2 time.Time
+}
+
+type testStruct struct {
+	Name    string `fyne:"field"`
+	Age     int    `fyne:"field"`
+	Address string `fyne:"field"`
+}
+
+func StringBind(s string) binding.DataItem {
+	return binding.BindString(&s).(binding.DataItem)
+}
+
+func IntBind(i int) binding.DataItem {
+	return binding.BindInt(&i).(binding.DataItem)
+}
+
+func FloatBind(i float64) binding.DataItem {
+	return binding.BindFloat(&i).(binding.DataItem)
+}
+
+func TestNewStructForm(t *testing.T) {
+	type args struct {
+		s      interface{}
+		submit func(s interface{}, err error)
+		cancel func()
+	}
+	type res struct {
+		fields   []reflect.StructField
+		widgets  []*widget.FormItem
+		bindings []binding.DataItem
+	}
+	tests := []struct {
+		name string
+		args args
+		want res
+	}{
+		{
+			"testFoo",
+			args{
+				testFoo{},
+				func(s interface{}, err error) {
+					if err != nil {
+						t.Error(err)
+					}
+					val, ok := s.(*testFoo)
+					if !ok {
+						t.Errorf("testFoo struct not created %v from %v", val, s)
+					}
+				},
+				func() {},
+			},
+			res{
+				fields: []reflect.StructField{
+					{
+						Name:   "Field1",
+						Type:   reflect.TypeOf(""),
+						Offset: 0,
+						Index:  []int{0},
+						Tag:    reflect.StructTag(`fyne:"field"`),
+					},
+					{
+						Name:   "Field3",
+						Type:   reflect.TypeOf(true),
+						Offset: 24,
+						Index:  []int{2},
+						Tag:    reflect.StructTag(`fyne:"field"`),
+					},
+					{
+						Name:   "Field4",
+						Type:   reflect.TypeOf(time.Time{}),
+						Offset: 32,
+						Index:  []int{3},
+						Tag:    reflect.StructTag(`fyne:"field"`),
+					},
+				},
+				widgets: []*widget.FormItem{
+					{
+						Text:   "Field1",
+						Widget: widget.NewEntry(),
+					},
+					{
+						Text:   "Field3",
+						Widget: widget.NewCheck("", func(b bool) {}),
+					},
+					{
+						Text:   "Field4",
+						Widget: NewCalendar(time.Now(), func(t time.Time) {}),
+					},
+				},
+			},
+		},
+		{
+			"testBar",
+			args{
+				testBar{},
+				func(s interface{}, err error) {
+					if err != nil {
+						t.Error(err)
+					}
+					val, ok := s.(*testBar)
+					if !ok {
+						t.Errorf("testFoo struct not created %v from %v", val, s)
+					}
+				},
+				func() {},
+			},
+			res{
+				fields: []reflect.StructField{
+					{
+						Name:   "Field1",
+						Type:   reflect.TypeOf(float64(1.0)),
+						Offset: 0,
+						Index:  []int{0},
+						Tag:    reflect.StructTag(`fyne:"field"`),
+					},
+				},
+				widgets: []*widget.FormItem{
+					{
+						Text:   "Field1",
+						Widget: NewNumericalEntry(),
+					},
+				},
+			},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := NewStructForm(tt.args.s, tt.args.submit, tt.args.cancel)
+			if len(got.fields) != len(got.widgets) {
+				t.Errorf("NewStructForm() len(fields) = %v != len(widgets) = %v", len(got.fields), len(got.widgets))
+			}
+			if len(got.fields) != len(got.bindings) {
+				t.Errorf("NewStructForm() len(fields) = %v != len(bindings) = %v", len(got.fields), len(got.bindings))
+			}
+
+			if len(got.fields) != len(tt.want.fields) {
+				t.Errorf("NewStructForm() len(fields) = %v, want %v", len(got.fields), len(tt.want.fields))
+			}
+			if !reflect.DeepEqual(got.fields, tt.want.fields) {
+				t.Errorf("NewStructForm().fields got %v want %v", got.fields, tt.want.fields)
+			}
+
+			if len(got.widgets) != len(tt.want.widgets) {
+				t.Errorf("NewStructForm().widgets got length %v, wanted %v", len(got.widgets), len(tt.want.widgets))
+			}
+			for i := 0; i < len(got.widgets) && i < len(tt.want.widgets); i += 1 {
+				if reflect.TypeOf(got.widgets[i].Widget) != reflect.TypeOf(tt.want.widgets[i].Widget) {
+					t.Errorf(
+						"NewStructForm().widgets[%v] = %v, want %v", i,
+						reflect.TypeOf(got.widgets[i].Widget), reflect.TypeOf(tt.want.widgets[i].Widget),
+					)
+				}
+			}
+			got.Submit()
+		})
+	}
+}