Fyne Thumbnail Proposal

At some point in the near future Fyne will need the ability to create thumbnails and load them as well as load them from cache. I am not familiar with thumbnailing outside of Linux using the xdg/fdo thumbnail manager spec. At a brief glance it would seem to use Window's system we would need to do it natively using syscalls. I would imagine we would need to do thumbnailing natively on ios/android as well due to storage locations and permissions. For now I have a working solution in FyFoto that follows the xdg/fdo spec and adapts to fallbacks for cross platform. Thumbnailing is done in a go routine and this is what the current code looks like: package main

import ( "crypto/md5" "encoding/hex" "fmt" "image" "image/png" "math" "os" "os/user" "time"

`"fyne.io/fyne"`
`"fyne.io/fyne/canvas"`

`"golang.org/x/image/draw"`

)

func thumbnail(ff *FyFoto, thumbQueue <-chan gridImage, quitQueue <-chan string) { for { select { case <-quitQueue: return case gi := <-thumbQueue: file := gi.imageFile base := "" xdgcache := os.Getenv("XDG_CACHE_HOME") if xdgcache == "" { usr, err := user.Current() if err != nil { fmt.Println("Could not find the current user") return } base = usr.HomeDir + "/.cache" } else { base = xdgcache } os.Mkdir(base, 0700) thumbDir := base + "/thumbnails" os.Mkdir(thumbDir, 0700) thumbDir += "/normal" os.Mkdir(thumbDir, 0700)

		`uri := []byte("file://" + file)`
		`newfileMD5 := md5.New()`
		`newfileMD5.Write(uri)`
		`newfile := hex.EncodeToString(newfileMD5.Sum(nil))`
		`destfile := thumbDir + "/" + newfile + ".png"`

		`needThumb := 1`
		`th, err := os.Stat(destfile)`
		`if !os.IsNotExist(err) {`
			`orig, _ := os.Stat(file)`
			`modThumb := th.ModTime()`
			`modOrig := orig.ModTime()`
			`diff := modThumb.Sub(modOrig)`
			`if diff > (time.Duration(0) * time.Second) {`
				`needThumb = 0`
			`}`
		`}`
		`if needThumb == 1 {`
			`img, err := os.Open(file)`
			`if err != nil {`
				`fmt.Println("Could not open image to thumbnail")`
				`img.Close()`
				`break`
			`}`
			`src, _, err := image.Decode(img)`
			`if err != nil {`
				`fmt.Println("Could not decode source image for thumbnail")`
				`img.Close()`
				`break`
			`}`
			`img.Close()`
			`img, err = os.Open(file)`
			`if err != nil {`
				`fmt.Println("Could not open image to thumbnail")`
				`img.Close()`
				`break`
			`}`
			`cfg, _, err := image.DecodeConfig(img)`
			`if err != nil {`
				`fmt.Println("Could not get original image size")`
				`img.Close()`
				`break`
			`}`
			`img.Close()`
			`newWidth, newHeight := 128, 128`
			`if cfg.Width > cfg.Height {`
				`scale := float64(cfg.Width) / float64(cfg.Height)`
				`newHeight = int(math.Round(float64(newWidth) / float64(scale)))`
			`} else if cfg.Height > cfg.Width {`
				`scale := float64(cfg.Height) / float64(cfg.Width)`
				`newWidth = int(math.Round(float64(newHeight) / float64(scale)))`
			`}`
			`dest := image.NewRGBA(image.Rect(0, 0, newWidth, newHeight))`
			`draw.NearestNeighbor.Scale(dest, dest.Bounds(), src, src.Bounds(), draw.Src, nil)`

			`out, err := os.Create(destfile)`
			`if err != nil {`
				`fmt.Println("Could not create thumbnail destination file")`
			`}`
			`err = png.Encode(out, dest)`
			`if err != nil {`
				`fmt.Println("Could not encode png for thumbnail")`
			`}`
		`}`
		`if &gi != nil && gi.imageDir == ff.currentDir {`
			`gi.imageObject = canvas.NewImageFromFile(destfile)`
			`gi.imageObject.FillMode = canvas.ImageFillContain`
			`size := int(math.Floor(float64(128 * ff.window.Canvas().Scale())))`
			`gi.imageObject.SetMinSize(fyne.NewSize(size, size))`
			`gi.Append(gi.imageObject)`

			`ff.images.AddObject(&gi)`
			`canvas.Refresh(ff.images)`
		`}`
	`}`
`}`

}

This would not be hard to adapt into canvas/image or widget/icon. What would be needed:

• A new API such as SetThumbnail(thumbnail bool) that if true would take the image resource and thumbnail it/get thumbnail from cache and use that as the displayed imaged.

Considerations:

• Is this cross platform enough where we take the trade off of potentially adding additional storage/duplication of thumbnails on platforms other than linux by adapting the fdo/xdg spec cross platform?
• Should we consider doing the thumbnails natively on platforms that require them be done that way including syscalls?
• Should we add in an API to switch the thumbnail size between the specs NORMAL and LARGE choices or should we just stick to NORMAL?
• What milestone would this need to be a part of?