Merge branch 'develop' into dynamic-cache-clean

Author: dweymouth

.github/workflows/mobile_tests.yml

@@ -26,7 +26,10 @@ jobs:
       - name: Get dependencies
         run: |
           sudo apt-get update
-          sudo apt-get install --no-install-recommends clang lld libegl1-mesa-dev libgles2-mesa-dev libx11-dev xorg-dev
+          sudo apt-get install --no-install-recommends clang lld libegl1-mesa-dev libgles2-mesa-dev libx11-dev xorg-dev fonts-noto-cjk
+
+      - name: Set environment variable LANG
+        run: echo "LANG=en_US.UTF-8" >> $GITHUB_ENV
 
       - name: Tests
         run: xvfb-run go test -race -tags mobile,ci,migrated_fynedo ./...

.github/workflows/platform_tests.yml

@@ -30,13 +30,13 @@ jobs:
       - name: Get dependencies
         run: |
           sudo apt-get update
-          sudo apt-get install --no-install-recommends bc clang lld libgl1-mesa-dev libwayland-dev libx11-dev libxkbcommon-dev xorg-dev xvfb language-pack-en
+          sudo apt-get install --no-install-recommends bc clang lld libgl1-mesa-dev libwayland-dev libx11-dev libxkbcommon-dev xorg-dev xvfb language-pack-en fonts-noto-cjk
           echo "CC=clang" >> "$GITHUB_ENV"
           echo "CGO_LDFLAGS=-fuse-ld=lld" >> "$GITHUB_ENV"
         if: ${{ runner.os == 'Linux' }}
 
       - name: Set environment variable LANG
-        run: export LANG=en_EN.UTF-8
+        run: echo "LANG=en_US.UTF-8" >> $GITHUB_ENV
         if: ${{ runner.os == 'Linux' }}
 
       - name: Tests

.github/workflows/static_analysis.yml

@@ -24,7 +24,7 @@ jobs:
           sudo apt-get install --no-install-recommends clang lld libegl1-mesa-dev libgl1-mesa-dev libgles2-mesa-dev libx11-dev xorg-dev xvfb language-pack-en
 
       - name: Set environment variable LANG
-        run: export LANG=en_EN.UTF-8
+        run: echo "LANG=en_US.UTF-8" >> $GITHUB_ENV
 
       - name: Install analysis tools
         run: |

README.md

@@ -32,8 +32,8 @@ After importing a new module, run the following command before compiling the cod
 
 To run a showcase of the features of Fyne execute the following:
 
-    go install fyne.io/fyne/v2/cmd/fyne_demo@latest
-    fyne_demo
+    go install fyne.io/demo@latest
+    demo
 
 And you should see something like this (after you click a few buttons):
 

app/meta_development.go

@@ -39,6 +39,11 @@ func checkLocalMetadata() {
 		if err == nil {
 			meta.Icon = metadata.ScaleIcon(res, 512)
 		}
+	} else { // Icon.png fallback
+		res, err := fyne.LoadResourceFromPath("Icon.png")
+		if err == nil {
+			meta.Icon = metadata.ScaleIcon(res, 512)
+		}
 	}
 
 	meta.Release = false

canvas/arbitrary_polygon.go

@@ -0,0 +1,69 @@
+package canvas
+
+import (
+	"image/color"
+
+	"fyne.io/fyne/v2"
+)
+
+// Declare conformity with CanvasObject interface
+var _ fyne.CanvasObject = (*ArbitraryPolygon)(nil)
+
+// ArbitraryPolygon describes a colored arbitrary polygon primitive in a Fyne canvas.
+// The polygon is defined by a list of vertex positions in clockwise order, specified in absolute coordinates
+// relative to the object (top-left is (0,0), bottom-right is (width,height)).
+// Each corner can have an individually specified rounding radius.
+//
+// Since: 2.8
+type ArbitraryPolygon struct {
+	baseObject
+
+	Points           []fyne.Position // Vertices in coordinates relative to the object. If NormalizedPoints is true, these are (0.0 to 1.0), otherwise absolute.
+	NormalizedPoints bool            // True if Points are specified in normalized coordinates (0.0 to 1.0) relative to the object's size.
+	CornerRadii      []float32       // Per-corner rounding radius, must match len(Points); missing entries default to 0
+	FillColor        color.Color     // The polygon fill color
+	StrokeColor      color.Color     // The polygon stroke color
+	StrokeWidth      float32         // The stroke width of the polygon
+}
+
+// Hide will set this arbitrary polygon to not be visible
+func (r *ArbitraryPolygon) Hide() {
+	r.baseObject.Hide()
+
+	repaint(r)
+}
+
+// Move the arbitrary polygon to a new position, relative to its parent / canvas
+func (r *ArbitraryPolygon) Move(pos fyne.Position) {
+	if r.Position() == pos {
+		return
+	}
+
+	r.baseObject.Move(pos)
+
+	repaint(r)
+}
+
+// Refresh causes this arbitrary polygon to be redrawn with its configured state.
+func (r *ArbitraryPolygon) Refresh() {
+	Refresh(r)
+}
+
+// Resize on an arbitrary polygon updates the new size of this object.
+func (r *ArbitraryPolygon) Resize(s fyne.Size) {
+	if s == r.Size() {
+		return
+	}
+
+	r.baseObject.Resize(s)
+
+	Refresh(r)
+}
+
+// NewArbitraryPolygon returns a new ArbitraryPolygon instance
+func NewArbitraryPolygon(points []fyne.Position, fill color.Color) *ArbitraryPolygon {
+	return &ArbitraryPolygon{
+		Points:    points,
+		FillColor: fill,
+	}
+}

canvas/arbitrary_polygon_test.go

@@ -0,0 +1,49 @@
+package canvas_test
+
+import (
+	"image/color"
+	"testing"
+
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/canvas"
+	"fyne.io/fyne/v2/test"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestArbitraryPolygon_NewAndDefaults(t *testing.T) {
+	points := []fyne.Position{
+		{X: 0, Y: 0},
+		{X: 100, Y: 0},
+		{X: 100, Y: 100},
+	}
+	fill := color.White
+	p := canvas.NewArbitraryPolygon(points, fill)
+
+	assert.Equal(t, points, p.Points)
+	assert.Equal(t, fill, p.FillColor)
+	assert.Nil(t, p.StrokeColor)
+	assert.Equal(t, float32(0), p.StrokeWidth)
+}
+
+func TestArbitraryPolygon_Properties(t *testing.T) {
+	p := canvas.NewArbitraryPolygon(nil, color.Black)
+	p.StrokeWidth = 2.0
+	p.StrokeColor = color.NRGBA{R: 255, G: 0, B: 0, A: 255}
+	p.CornerRadii = []float32{5, 10, 5}
+
+	assert.Equal(t, float32(2.0), p.StrokeWidth)
+	assert.Equal(t, color.NRGBA{R: 255, G: 0, B: 0, A: 255}, p.StrokeColor)
+	assert.Equal(t, []float32{5, 10, 5}, p.CornerRadii)
+}
+
+func TestArbitraryPolygon_RendersToMarkup(t *testing.T) {
+	points := []fyne.Position{
+		{X: 0, Y: 0},
+		{X: 10, Y: 0},
+		{X: 10, Y: 10},
+	}
+	p := canvas.NewArbitraryPolygon(points, color.White)
+	p.Resize(fyne.NewSize(10, 10))
+
+	test.AssertObjectRendersToMarkup(t, "arbitrary_polygon.xml", p)
+}

canvas/blur.go

@@ -0,0 +1,56 @@
+package canvas
+
+import "fyne.io/fyne/v2"
+
+// Declare conformity with CanvasObject interface
+var _ fyne.CanvasObject = (*Blur)(nil)
+
+// Blur creates a rectangular blur region on the output.
+// All objects drawn under this will be blurred, any above will not be affected.
+//
+// Since: 2.7
+type Blur struct {
+	baseObject
+
+	// Radius refers to how far from a point should be used to calculate the blur.
+	// It must be greater than 0 but no more than 50.
+	Radius float32
+}
+
+// Hide will set this blur to not be visible
+func (b *Blur) Hide() {
+	b.baseObject.Hide()
+
+	repaint(b)
+}
+
+// Move the blur to a new position, relative to its parent / canvas
+func (b *Blur) Move(pos fyne.Position) {
+	if b.Position() == pos {
+		return
+	}
+	b.baseObject.Move(pos)
+
+	repaint(b)
+}
+
+// Refresh causes this blur to be redrawn with its configured state.
+func (b *Blur) Refresh() {
+	Refresh(b)
+}
+
+// Resize on a blur updates the new size of this object.
+func (b *Blur) Resize(s fyne.Size) {
+	if s == b.Size() {
+		return
+	}
+
+	b.baseObject.Resize(s)
+}
+
+// NewBlur returns a new Blur instance
+func NewBlur(radius float32) *Blur {
+	return &Blur{
+		Radius: radius,
+	}
+}

canvas/blur_test.go

@@ -0,0 +1,26 @@
+package canvas_test
+
+import (
+	"testing"
+
+	"fyne.io/fyne/v2"
+	"fyne.io/fyne/v2/canvas"
+	"fyne.io/fyne/v2/container"
+	"fyne.io/fyne/v2/test"
+)
+
+func TestBlur(t *testing.T) {
+	test.NewTempApp(t)
+	bg := canvas.NewImageFromFile("testdata/Utah_teapot.png")
+	b1 := canvas.NewBlur(35)
+	w := test.NewTempWindow(t, container.NewWithoutLayout(bg, b1))
+	w.SetPadded(false)
+	size := fyne.NewSize(300, 243)
+	bg.Resize(size)
+	w.Resize(size)
+
+	b1.Move(fyne.NewPos(120, 110))
+	b1.Resize(fyne.NewSize(140, 100))
+
+	test.AssertRendersToImage(t, "blur.png", w.Canvas())
+}

canvas/canvas.go

@@ -13,6 +13,10 @@ const (
 	// This constant represents the maximum possible corner radius, resulting in a circular appearance.
 	// Since: 2.7
 	RadiusMaximum float32 = math.MaxFloat32
+
+	// ArbitraryPolygonVerticesMaximum defines the maximum number of vertices supported by the arbitrary polygon
+	// Since: 2.8
+	ArbitraryPolygonVerticesMaximum = 16
 )
 
 // Refresh instructs the containing canvas to refresh the specified obj.