Proposal: Use Vectors to Represent Position, Size, Etc.

Note

This document is archived as it refers to a design process.

Update 2020-12-31: this proposal has been implemented in #1661.

---

I'm new around here, and this was something that niggled me while I was writing my first application to get a feel for Fyne.

There are at least two different types: fyne.Position and fyne.Size that are different ways of thinking of a 2-tuple.

I propose that the geometry.go should be modified to be backed by a common vector/matrix type. This would make polymorphism between the Position and Size types easier. This also possibly gives an avenue by which to solve #835. The proposed approach here does break compatibility with the existing types though, to accommodate switching from a struct-based position and size type to an interface-based approach. However, refactoring code to instead use the vector type would be very straightforward.

Using this interface-based style also has the advantage of allowing polymorphism with other future types we may not be able to anticipate yet. It would also allow us to wrap third-party types, which may be convenient for us or for other developers using our library.

The following code is provided to illustrate this idea:

package main

import (
	"fmt"
	"math"
)

type Vec2 struct {
	X float64
	Y float64
}

func NewVec2(x, y float64) Vec2 {
	return Vec2{x, y}
}

func (v Vec2) Add(u Vec2) Vec2 {
	return NewVec2(u.X+v.X, u.Y+v.Y)
}

func (v Vec2) String() string {
	return fmt.Sprintf("[%f, %f]", v.X, v.Y)
}

type Position interface {
	GetX() float64
	GetY() float64
}

func (v Vec2) GetX() float64 {
	return v.X
}

func (v Vec2) GetY() float64 {
	return v.Y
}

type Size interface {
	GetWidth() float64
	GetHeight() float64
	Max(Size) Size
}

func (v Vec2) GetWidth() float64 {
	return v.X
}

func (v Vec2) GetHeight() float64 {
	return v.Y
}

func (s1 Vec2) Max(s2 Vec2) Vec2 {
	return NewVec2(math.Max(s1.GetWidth(), s2.GetWidth()), math.Max(s1.GetHeight(), s2.GetHeight()))
}

func main() {
	v1 := NewVec2(1, 2)
	v2 := NewVec2(2, 3.5)
	v3 := v1.Add(v2)

	fmt.Printf("v1=%s, v2=%s, v3=%s\n", v1, v2, v3)

	fmt.Printf("v1.Max(v2)=%s\n", v1.Max(v2))
}

It would be worthwhile to consider and discuss the merits of having GetX(), GetY() and GetWidth() GetHeight() methods, versus just updating the things that operate on Position and Size to use the X and Y fields of Vec2 directly, which might be simpler, though is potentially harder to read (I would argue that this is a common enough convention in UI toolkits that the additionally difficulty to read such could would be negligible).

As a point in favor of the interface-based approach, it would become very easy to build say a PhysicalScreenPosition interface that returned integers, abstracting over the typecast inside of the interface methods.

It may also be worth considering whether or not the same types are sensible for both drawing to the screen, and for developers to implement canvases with. There is some (valid) concern about resource utilization with floating point values. This makes sense for implementing arbitrary geometry, but maybe not when rendering buttons.

---

Edit 1: Following further discussion, here are some variations on this idea that might also be worth considering.

Directly declaring type Position Vec2 and so on:

package main

import (
	"fmt"
	"math"
)

type Vec2 struct {
	X float64
	Y float64
}

func NewVec2(x, y float64) Vec2 {
	return Vec2{x, y}
}

func (v Vec2) Add(u Vec2) Vec2 {
	return NewVec2(u.X+v.X, u.Y+v.Y)
}

func (v Vec2) String() string {
	return fmt.Sprintf("[%f, %f]", v.X, v.Y)
}

type Position Vec2

type Size Vec2

func (s1 Size) Max(s2 Size) Size {
	return Size(NewVec2(math.Max(s1.X, s2.X), math.Max(s1.Y, s2.Y)))
}

func main() {
	v1 := NewVec2(1, 2)
	v2 := NewVec2(2, 3.5)
	v3 := v1.Add(v2)

	fmt.Printf("v1=%s, v2=%s, v3=%s\n", v1, v2, v3)

	fmt.Printf("v1.Max(v2)=%s\n", Size(v1).Max(Size(v2)))
}

The same thing, using complex64:

package main

import (
	"fmt"
	"math"
)

type Vec2 complex64

func NewVec2(x, y float32) Vec2 {
	return Vec2(complex(x, y))
}

func (v Vec2) Add(u Vec2) Vec2 {
	return Vec2(complex64(v) + complex64(u))
}

func (v Vec2) X() float32 {
	return real(v)
}

func (v Vec2) Y() float32 {
	return imag(v)
}

func (v Vec2) String() string {
	return fmt.Sprintf("[%f, %f]", v.X(), v.Y())
}

type Position Vec2

type Size Vec2

func (s Size) Width() float32 {
	return Vec2(s).X()
}

func (s Size) Height() float32 {
	return Vec2(s).X()
}

func (s1 Size) Max(s2 Size) Size {
	// return Size(NewVec2(float32(math.Max(float64(s1.X()), float64*s2.X())), float32(math.Max(float64(s1.Y()), float64(s2.Y())))))
	width := float32(math.Max(float64(s1.Width()), float64(s2.Width())))
	height := float32(math.Max(float64(s1.Height()), float64(s2.Height())))
	return Size(NewVec2(width, height))
}

func (s Size) String() string {
	return fmt.Sprintf("%f x %f", s.Width(), s.Height())
}

func main() {
	v1 := NewVec2(1, 2)
	v2 := NewVec2(2, 3.5)
	v3 := v1.Add(v2)

	fmt.Printf("v1=%s, v2=%s, v3=%s\n", v1, v2, v3)

	fmt.Printf("v1.Max(v2)=%s\n", Size(v1).Max(Size(v2)))
}

(I think previous one was better, I don't think the complex64 thing is the way to go --Charles)