passgo/cmd/passgo-gui/main.go

// +build darwin linux

package main

import (
	"fmt"
	"io/ioutil"
	"os"
	"path"
	"runtime"
	"runtime/pprof"
	"strconv"
	"strings"
	"sync"
	"time"

	"gioui.org/app"
	"gioui.org/font/gofont"
	"gioui.org/io/key"
	"gioui.org/io/system"
	"gioui.org/layout"
	"gioui.org/op"
	"gioui.org/text"
	"gioui.org/unit"
	"gioui.org/widget"
	"gioui.org/widget/material"

	"github.com/fsnotify/fsnotify"
	"gopkg.in/yaml.v2"

	"git.wow.st/gmp/passgo"
	"git.wow.st/gmp/rand"
)

type (
	D = layout.Dimensions
	C = layout.Context
)

type conf struct {
	StoreDir   string
	ClearDelay int
}

func main() {
	if false { go func() {
		f, err := os.Create("cpuprofile")
		if err != nil {
			fmt.Printf("Can't create CPU profile\n")
			os.Exit(-1)
		}
		fmt.Printf("Starting CPU profile\n")
		if err := pprof.StartCPUProfile(f); err != nil {
			fmt.Printf("Can't start CPU profile\n")
			f.Close()
			os.Exit(-1)
		}
		time.Sleep(time.Second * 10)
		fmt.Printf("Stopping CPU profile\n")
		pprof.StopCPUProfile()
		f.Close()
		fmt.Printf("CPU profile written\n")
	}() }
	var fd *os.File
	var err error
	confDir, err = getConfDir()
	if err != nil {
		fmt.Printf("Can't get config directory")
		os.Exit(-1)
	}
	confFile := path.Join(confDir, "config.yml")
	if _, err := os.Stat(confFile); os.IsNotExist(err) {
		fd, err = os.Create(confFile)
		if err != nil {
			log(Fatal, "Cannot create configuration file: ", err)
		}
	}

	confbytes, err := ioutil.ReadFile(confFile)
	if err != nil {
		log(Fatal, "Cannot read configuration file: ", err)
	}
	if err = yaml.UnmarshalStrict(confbytes, &Config); err != nil {
		log(Fatal, "Cannot parse configuration file: ", err)
	}
	store.Dir = Config.StoreDir
	log(Info, " StoreDir = ", store.Dir)
	go func() {
		err = passgo.GetStore(&store)
		if err != nil {
			log(Info, err)
		}
	}()
	if Config.ClearDelay == 0 {
		Config.ClearDelay = 45
	}

	if fd != nil { // we still have an empty conf file open:
		Config.StoreDir = store.Dir
		saveConf(fd)
	}

	reload = make(chan struct{})
	updated = make(chan struct{})
	chdir = make(chan struct{})
	passch = make(chan []byte)

	go func() {
		log(Info,"passgo.Identities()")
		passgo.Identities()
	}()
	go Updater()
	log(Info, "Staring event loop")
	go eventLoop()
	app.Main()
	log(Info, "Event loop returned")
}

var (
	fontSize float32
	collection []text.FontFace
	confDir string
	Config  conf
	l       []passgo.Pass
	mux     sync.Mutex
	store   passgo.Store
	reload  chan struct{}
	updated chan struct{}
	chdir   chan struct{}
	passch  chan []byte
	th *material.Theme
)

func Updater() {
	//time.Sleep(time.Second * 2)
	update := func() {
		fmt.Printf("update()\n")
		ltmp, err := store.List()
		if err != nil {
			log(Info, err)
		}
		mux.Lock()
		l = ltmp
		mux.Unlock()
		updated <- struct{}{}
	}
	update()

	watcher, err := fsnotify.NewWatcher()
	if err != nil {
		log(Fatal, err)
	}
	dir := store.Dir
	watcher.Add(dir)
	for {
		select {
		case <-reload:
			update()
		case <-watcher.Events:
			update()
		case e := <-watcher.Errors:
			log(Info, "Watcher error: ", e)
		case <-chdir:
			err := watcher.Remove(dir)
			if err != nil {
				log(Info, "Error removing watcher: ", err)
			}
			watcher.Add(store.Dir)
			update()
		}
	}
}

func saveConf(fds ...*os.File) {
	var fd *os.File
	var err error
	if len(fds) > 0 && fds[0] != nil {
		fd = fds[0]
	} else {
		fd, err = os.Create(path.Join(confDir, "config.yml"))
		if err != nil {
			log(Error, "Config file = ", path.Join(confDir, "config.yml"))
			log(Fatal, "Cannot open config file: ", err.Error())
		}
	}
	defer fd.Close()

	confbytes, err := yaml.Marshal(Config)
	if err != nil {
		log(Fatal, "Cannot save configuration: ", err)
	}
	_, err = fd.Write(confbytes)
	if err != nil {
		log(Fatal, "Cannot write to configuration: ", err)
	}
}

func eventLoop() {
	if collection == nil {
		collection = gofont.Collection()
	}

	var ops op.Ops
	th = material.NewTheme(collection)
	th.TextSize = unit.Sp(fontSize)
	w := app.NewWindow(
		app.Size(unit.Dp(250), unit.Dp(500)),
		app.Title("passgo"))

	var margincs layout.Constraints

	var c1 layout.FlexChild // flex child for title bar

	sysinset := &layout.Inset{}
	margin := layout.UniformInset(unit.Dp(10))

	title := material.Body1(th, "passgo")
	dotsBtn := &Button{
		Size:       unit.Sp(fontSize),
		Label:      "\xe2\x8b\xae",
		Alignment:  text.Middle,
		Color:      black,
		Background: gray,
	}

	titleflex := &layout.Flex{Axis: layout.Horizontal}

	flex := &layout.Flex{Axis: layout.Vertical}
	lst := &layout.List{Axis: layout.Vertical}
	passBtns := make([]*Button, 0)
	pathnames := make([]string, 0)
	copied := &Overlay{Size: unit.Sp(fontSize), Text: "copied to clipboard",
		Color:      black,
		Background: darkgray,
		Alignment:  text.Middle,
	}
	cleared := &Overlay{Size: unit.Sp(fontSize), Text: "clipboard cleared",
		Color:      black,
		Background: darkgray,
		Alignment:  text.Middle,
	}
	overlay := copied
	var overlayStart time.Time

	FilterEd := &widget.Editor{SingleLine: true}
	updateBtns := func() {
		passBtns = passBtns[:0]
		pathnames = pathnames[:0]
		dirs := make(map[string]bool) // visited pathnames

		var addd, addf func(x passgo.Pass)
		addd = func(x passgo.Pass) {
			if x.Level < 1 {
				return
			}
			d, n := path.Split(x.Pathname)
			x = passgo.Pass{
				Pathname: d,
				Level: x.Level - 1,
				Dir: true,
			}
			fmt.Printf("addd(): d/n = '%s'/'%s'\n", d,n)
			if dirs[d] != true {
				addd(x)
			}
			dirs[x.Pathname] = true
			s := strings.Repeat("  /", x.Level)
			lbl := strings.Join([]string{s, d}, "")
			passBtns = append(passBtns, &Button{
				Size:  unit.Sp(fontSize),
				Label: lbl,
				Background: gray,
			})
			pathnames = append(pathnames, x.Pathname)
		}

		flt := strings.ToUpper(FilterEd.Text())
		addf = func(x passgo.Pass) {
			if !strings.Contains(strings.ToUpper(x.Pathname), flt) {
				return
			}
			d, n := path.Split(x.Pathname)
			s := strings.Repeat("  /", x.Level)
			lbl := strings.Join([]string{s, n}, "")
			if dirs[d] != true {
				addd(x)
			}
			passBtns = append(passBtns, &Button{
				Size:       unit.Sp(fontSize),
				Label:      lbl,
				Background: gray,
			})
			pathnames = append(pathnames, x.Pathname)
		}
		mux.Lock()
		for _, x := range l {
			if !x.Dir {
				addf(x)
			}
		}
		mux.Unlock()
	}

	idBtns := make([]*Button, 0)

	updateIdBtns := func() {
		log(Info,"passgo.Identities()")
		ids, err := passgo.Identities()
		if err != nil {
			log(Info, err)
			return
		}
		for i, n := range ids {
			if i >= len(idBtns) {
				idBtns = append(idBtns, &Button{
					Size:       unit.Sp(fontSize),
					Label:      n,
					Alignment:  text.End,
					Color:      black,
					Background: gray,
				})
			} else {
				idBtns[i].Label = n
			}
		}
		idBtns = idBtns[:len(ids)]
	}

	confBtn := &Button{
		Size:       unit.Sp(fontSize),
		Label:      "configure",
		Alignment:  text.Middle,
		Color:      black,
		Background: gray,
	}

	storeDirLabel := material.Label(th, unit.Sp(fontSize), "Store directory")
	storeDirEd := &widget.Editor{ SingleLine: true}
	storeDirEd.SetText(store.Dir)
	saveBtn := &Button{
		Size:       unit.Sp(fontSize),
		Label:      "save",
		Alignment:  text.End,
		Color:      black,
		Background: gray,
	}
	backBtn := &Button{
		Size:       unit.Sp(fontSize),
		Label:      "back",
		Alignment:  text.End,
		Color:      black,
		Background: gray,
	}
	confirmLabel := material.Label(th, unit.Sp(fontSize), "Password exists. Overwrite?")
	yesBtn := &Button{
		Size:       unit.Sp(fontSize),
		Label:      "yes",
		Alignment:  text.End,
		Color:      black,
		Background: gray,
	}

	promptLabel := material.Label(th, unit.Sp(fontSize), "passphrase")
	promptEd := &widget.Editor{ SingleLine: true, Submit: true }
	okBtn := &Button{
		Size:       unit.Sp(fontSize),
		Label:      "ok",
		Alignment:  text.End,
		Color:      black,
		Background: gray,
	}
	plusBtn := &Button{
		Size:       unit.Sp(fontSize),
		Label:      "+",
		Alignment:  text.Middle,
		Color:      black,
		Background: gray,
	}
	xBtn := &Button{
		Size:       unit.Sp(fontSize),
		Label:      "X",
		Alignment:  text.Middle,
		Color:      black,
		Background: gray,
	}

	insertLabel := material.Label(th, unit.Sp(fontSize), "Insert")
	passnameLabel := material.Label(th, unit.Sp(fontSize), "password name:")
	passnameEd := &widget.Editor{ SingleLine: true }
	passvalLabel := material.Label(th, unit.Sp(fontSize), "password value:")
	passvalEd := &widget.Editor{ SingleLine: true, Submit: true }

	noidLabel := material.Label(th, unit.Sp(fontSize), noidLabelText)
	idLabel := material.Label(th, unit.Sp(fontSize), "Select ID")

	anim := &time.Ticker{}
	animating := false
	animOn := func() {
		log(Info, "animOn()")
		anim = time.NewTicker(time.Second / 90)
		animating = true
		w.Invalidate()
	}
	animOff := func() {
		log(Info, "animOff()")
		anim.Stop()
		animating = false
	}

	var listPage, idPage, insertPage, confirmPage, confPage, promptPage, page func(C) D
	_ = idPage

	prompt := func() []byte {
		page = promptPage
		promptEd.SetText("")
		w.Invalidate()
		return <-passch
	}

	lpf1 := &layout.Flex{Axis: layout.Horizontal}
	listPage = func(gtx C) D {
		// timing variables used for animation
		fade1a, fade1b := 1.5, 2.0
		start2 := float64(Config.ClearDelay)
		fade2a, end := start2+1.5, start2+2.0

		c2 := layout.Rigid(func(gtx C) D {
			c21 := layout.Flexed(1, func(gtx C) D {
				return material.Editor(th, FilterEd, "filter").Layout(gtx)
			})
			c22 := layout.Rigid(func(gtx C) D {
				return xBtn.Layout(gtx)
			})
			if xBtn.Clicked() {
				FilterEd.SetText("")
				updateBtns()
			}
			return lpf1.Layout(gtx, c21, c22)
		})
		c3 := layout.Flexed(1.0, func(gtx C) D {
			var ret D
			mux.Lock()
			if lst.Dragging() {
				key.HideInputOp{}.Add(gtx.Ops)
			}
			switch {
			case store.Empty:
				confBtn.Layout(gtx)
				if confBtn.Clicked() {
					log(Info, "Configure")
					w.Invalidate()
					page = confPage
				}
			case store.Id == "":
				idLabel.Layout(gtx)
				w.Invalidate()
				page = idPage
			default:
				ret = lst.Layout(gtx, len(passBtns), func(gtx C, i int) D {
					btn := passBtns[i]
					gtx.Constraints.Min.X = gtx.Constraints.Max.X
					ret := btn.Layout(gtx)
					if btn.Clicked() {
						log(Info, "Clicked ", btn.Label)
						// don't block UI thread on decryption attempt
						go func(name string) {
							p, err := store.Decrypt(name, prompt)
							//p, err := store.Decrypt(name)
							if err == nil {
								passgo.Clip(p)
								overlayStart = time.Now()
								overlay = copied
								overlay.Color = black
								overlay.Background = darkgray
								w.Invalidate()
								go func() {
									time.Sleep(time.Millisecond * time.Duration(fade1a*1000))
									animOn()
								}()
								go func() {
									time.Sleep(time.Millisecond * time.Duration(Config.ClearDelay*1000))
									log(Info, "clearing clipboard")
									passgo.Clip("")
								}()
							} else {
								log(Info, "Can't decrypt ", name)
								log(Info, err)
							}
						}(pathnames[i])
					}
					return ret
				})
			}
			mux.Unlock()
			return ret
		})
		ret := flex.Layout(gtx, c1, c2, c3)
		x := time.Since(overlayStart).Seconds()
		if x >= fade1b && x < start2 && animating {
			animOff()
			go func() {
				time.Sleep(time.Millisecond * time.Duration((start2-x)*1000))
				w.Invalidate()
				time.Sleep(time.Millisecond * time.Duration((fade2a-start2)*1000))
				animOn()
			}()
		}
		if (x >= fade1a && x < fade1b) || (x > fade2a && x < end) {
			if !animating {
				animOn()
			}
			var fade float64
			switch {
			case x < fade1b:
				fade = (fade1b - x) / (fade1b - fade1a)
			case x > fade2a:
				fade = (end - x) / (end - fade2a)
			}
			overlay.Color.R = uint8(float64(black.R) * fade)
			overlay.Color.G = uint8(float64(black.G) * fade)
			overlay.Color.B = uint8(float64(black.B) * fade)
			overlay.Color.A = uint8(float64(black.A) * fade)
			overlay.Background.R = uint8(float64(darkgray.R) * fade)
			overlay.Background.G = uint8(float64(darkgray.G) * fade)
			overlay.Background.B = uint8(float64(darkgray.B) * fade)
			overlay.Background.A = uint8(float64(darkgray.A) * fade)
		}
		if x <= fade1b || (x > start2 && x < end) {
			if x > start2 && overlay == copied {
				overlay = cleared
				overlay.Color = black
				overlay.Background = darkgray
			}
			gtx.Constraints = margincs
			layout.SE.Layout(gtx, func(gtx C) D {
				gtx.Constraints.Min.X = gtx.Constraints.Max.X
				return overlay.Layout(gtx)
			})
		}
		if x > start2 && x < fade2a {
			//	animOff()
		}
		if animating && x > end {
			animOff()
		}
		if len(FilterEd.Events()) > 0 {
			updateBtns()
		}
		return ret
	}

	updateBtn := &Button{
		Size:       unit.Sp(fontSize),
		Label:      "Update",
		Alignment:  text.Middle,
		Color:      black,
		Background: gray,
	}
	idEd := &widget.Editor{SingleLine: true, Submit: true}
	idSubmitBtn := &Button{
		Size:       unit.Sp(fontSize),
		Label:      "Submit",
		Alignment:  text.Middle,
		Color:      black,
		Background: gray,
	}

	idPage = func(gtx C) D {
		if !animating {
			animOn()
		}
		c2 := layout.Rigid(func(gtx C) D {
			return idLabel.Layout(gtx)
		})
		var c3 layout.FlexChild
		var c4 layout.FlexChild
		var c5 layout.FlexChild
		var c6 layout.FlexChild
		var c7 layout.FlexChild
		if len(idBtns) == 0 {
			c3 = layout.Rigid(func(gtx C) D {
				return updateBtn.Layout(gtx)
			})
			if updateBtn.Clicked() {
				updateIdBtns()
				w.Invalidate()
			}
			c4 = layout.Rigid(func(gtx C) D {
				return material.Editor(th, idEd, "id").Layout(gtx)
			})
			for _, e := range idEd.Events() {
				switch e.(type) {
				case widget.SubmitEvent:
					log(Info, "Submit")
					store.Id = idEd.Text()
					page = listPage
				}
			}
			c5 = layout.Rigid(func(gtx C) D {
				return idSubmitBtn.Layout(gtx)
			})
			if idSubmitBtn.Clicked() {
				store.Id = idEd.Text()
				page = listPage
			}
			c6 = layout.Rigid(func(gtx C) D {
				return noidLabel.Layout(gtx)
			})
		} else {
			c3 = layout.Rigid(func(gtx C) D { return D{} })
			c4 = layout.Rigid(func(gtx C) D { return D{} })
			c5 = layout.Rigid(func(gtx C) D { return D{} })
			c6 = layout.Rigid(func(gtx C) D { return D{} })
		}
		c7 = layout.Rigid(func(gtx C) D {
			var ret D
			if len(idBtns) > 0 { // still zero after update
				for i := 0; i < len(idBtns); i++ {
					ret = lst.Layout(gtx, len(idBtns), func(gtx C, i int) D {
						return idBtns[i].Layout(gtx)
					})
				}
				for _, btn := range idBtns {
					if btn.Clicked() {
						log(Info, "ID selected: ", btn.Label)
						store.SetID(btn.Label)
						w.Invalidate()
						animOff()
						page = listPage
					}
				}
			}
			return ret
		})
		return flex.Layout(gtx, c1, c2, c3, c4, c5, c6, c7)
	}

	var insName, insValue string
	genBtn := &SelButton{SelColor: gray}
	genBtn.Button = Button{Size: unit.Sp(fontSize), Label: "generate"}
	symBtn := &SelButton{SelColor: gray}
	numBtn := &SelButton{SelColor: gray}
	symBtn.Button = Button{Size: unit.Sp(fontSize), Label: "@"}
	numBtn.Button = Button{Size: unit.Sp(fontSize), Label: "#"}
	symBtn.Select()
	numBtn.Select()
	lenEd := &widget.Editor{ SingleLine: true, Alignment: text.End }
	lenEd.SetText("15")
	lBtn := &Button{Size: unit.Sp(fontSize), Label: "<", Background: gray}
	rBtn := &Button{Size: unit.Sp(fontSize), Label: ">", Background: gray}

	updatePw := func() {
		if !genBtn.Selected {
			passvalEd.SetText("")
			return
		}
		var gen rand.Generator
		switch {
		case symBtn.Selected && numBtn.Selected:
			gen = rand.Char
		case symBtn.Selected:
			gen = rand.LettersSymbols
		case numBtn.Selected:
			gen = rand.LetterDigits
		default:
			gen = rand.Letter
		}
		l, _ := strconv.Atoi(lenEd.Text())
		pw, _ := rand.Slice(gen, l)
		passvalEd.SetText(string(pw))
	}

	insertPage = func(gtx C) D {
		c2 := layout.Rigid(func(gtx C) D { return insertLabel.Layout(gtx) })
		c3 := layout.Rigid(func(gtx C) D { return passnameLabel.Layout(gtx) })
		c4 := layout.Rigid(func(gtx C) D { return material.Editor(th, passnameEd, "name").Layout(gtx) })
		c5 := layout.Rigid(func(gtx C) D { return passvalLabel.Layout(gtx) })
		c6 := layout.Rigid(func(gtx C) D { return material.Editor(th, passvalEd, "password").Layout(gtx) })

		btnflx := &layout.Flex{Axis: layout.Horizontal}
		c7 := layout.Rigid(func(gtx C) D {
			bc1 := layout.Rigid(func(gtx C) D { return lBtn.Layout(gtx) })
			bc2 := layout.Rigid(func(gtx C) D {
				gtx.Constraints.Min.X = 60
				return material.Editor(th, lenEd, "len").Layout(gtx)
			})

			bc3 := layout.Rigid(func(gtx C) D { return rBtn.Layout(gtx) })
			bc4 := layout.Rigid(func(gtx C) D { return symBtn.Layout(gtx) })
			bc5 := layout.Rigid(func(gtx C) D { return numBtn.Layout(gtx) })
			bc6 := layout.Rigid(func(gtx C) D { return genBtn.Layout(gtx) })

			return layout.E.Layout(gtx, func(gtx C) D {
				return btnflx.Layout(gtx, bc1, bc2, bc3, bc4, bc5, bc6)
			})
		})

		c8 := layout.Rigid(func(gtx C) D {
			bc1 := layout.Rigid(func(gtx C) D { return backBtn.Layout(gtx) })
			bc2 := layout.Rigid(func(gtx C) D { return saveBtn.Layout(gtx) })
			return layout.E.Layout(gtx, func(gtx C) D {
				return btnflx.Layout(gtx, bc1, bc2)
			})
		})

		ret := flex.Layout(gtx, c1, c2, c3, c4, c5, c6, c7, c8)

		if lBtn.Clicked() {
			l, _ := strconv.Atoi(lenEd.Text())
			if l > 0 {
				l -= 1
			}
			lenEd.SetText(strconv.Itoa(l))
			updatePw()
			w.Invalidate()
		}
		if rBtn.Clicked() {
			l, _ := strconv.Atoi(lenEd.Text())
			lenEd.SetText(strconv.Itoa(l + 1))
			updatePw()
			w.Invalidate()
		}
		if genBtn.Clicked() {
			updatePw()
			w.Invalidate()
		}
		if symBtn.Clicked() {
			updatePw()
			w.Invalidate()
		}
		if numBtn.Clicked() {
			updatePw()
			w.Invalidate()
		}
		if backBtn.Clicked() {
			w.Invalidate()
			page = listPage
		}
		if saveBtn.Clicked() {
			w.Invalidate()
			page = listPage
			insName = passnameEd.Text()
			insValue = passvalEd.Text()
			for _, n := range pathnames {
				if insName == n {
					log(Info, "Password exists")
					page = confirmPage
					w.Invalidate()
					return ret
				}
			}
			//Do not block the UI thread.
			go func() {
				err := store.Insert(passnameEd.Text(), passvalEd.Text())
				if err != nil {
					page = idPage
				}
			}()
		}
		return ret
	}

	confirmPage = func(gtx C) D {
		c2 := layout.Rigid(func(gtx C) D {
			return confirmLabel.Layout(gtx)
		})
		btnflx := &layout.Flex{Axis: layout.Horizontal}
		c3 := layout.Rigid(func(gtx C) D {
			bc1 := layout.Rigid(func(gtx C) D { return backBtn.Layout(gtx) })
			bc2 := layout.Rigid(func(gtx C) D { return yesBtn.Layout(gtx) })

			return layout.E.Layout(gtx, func(gtx C) D {
				return btnflx.Layout(gtx, bc1, bc2)
			})
		})
		ret := flex.Layout(gtx, c1, c2, c3)

		if backBtn.Clicked() {
			w.Invalidate()
			page = insertPage
		}
		if yesBtn.Clicked() {
			w.Invalidate()
			page = listPage
			go func() {
				err := store.Insert(insName, insValue)
				if err != nil {
					page = idPage
				}
			}()
		}
		return ret
	}

	confPage = func(gtx C) D {
		c2 := layout.Rigid(func(gtx C) D { return storeDirLabel.Layout(gtx) })
		c3 := layout.Rigid(func(gtx C) D { return material.Editor(th, storeDirEd, "directory").Layout(gtx) })

		c4 := layout.Rigid(func(gtx C) D {
			btnflx := &layout.Flex{Axis: layout.Horizontal}
			bc1 := layout.Rigid(func(gtx C) D {
				return backBtn.Layout(gtx)
			})
			bc2 := layout.Rigid(func(gtx C) D {
				return saveBtn.Layout(gtx)
			})
			return layout.E.Layout(gtx, func(gtx C) D {
				return btnflx.Layout(gtx, bc1, bc2)
			})
		})
		ret := flex.Layout(gtx, c1, c2, c3, c4)

		if backBtn.Clicked() {
			log(Info, "Back")
			storeDirEd.SetText(store.Dir)
			w.Invalidate()
			page = listPage
		}
		if saveBtn.Clicked() {
			log(Info, "Save")
			go func() { // do not block UI thread
				store.Dir = storeDirEd.Text()
				store.Id = ""
				passgo.GetStore(&store)
				Config.StoreDir = store.Dir
				store.Mkdir()
				saveConf()
				chdir <- struct{}{}
			}()
			w.Invalidate()
			page = listPage
		}
		return ret
	}

	promptPage = func(gtx C) D {
		submit := false
		for _, e := range promptEd.Events() {
			switch e.(type) {
			case widget.SubmitEvent:
				log(Info, "Submit")
				submit = true
			}
		}
		c2 := layout.Rigid(func(gtx C) D { return promptLabel.Layout(gtx) })
		c3 := layout.Rigid(func(gtx C) D { return material.Editor(th, promptEd, "password").Layout(gtx) })
		c4 := layout.Rigid(func(gtx C) D {
			btnflx := &layout.Flex{Axis: layout.Horizontal}
			bc1 := layout.Rigid(func(gtx C) D {
				return backBtn.Layout(gtx)
			})
			bc2 := layout.Rigid(func(gtx C) D {
				return okBtn.Layout(gtx)
			})
			return layout.E.Layout(gtx, func(gtx C) D {
				return btnflx.Layout(gtx, bc1, bc2)
			})
		})
		ret := flex.Layout(gtx, c1, c2, c3, c4)

		if submit || okBtn.Clicked() {
			log(Info, "Ok")
			go func() { // do not block UI thread
				passch <- []byte(promptEd.Text())
			}()
			w.Invalidate()
			page = listPage
		}
		if backBtn.Clicked() {
			log(Info, "Back")
			go func() {
				passch <- nil // cancel prompt
			}()
			w.Invalidate()
			page = listPage
		}
		return ret
	}

	page = listPage

	ms := &runtime.MemStats{}
	x := 0
	var mallocs uint64
	for {
		select {
		case <-updated:
			log(Info, "UPDATE")
			updateBtns()
			w.Invalidate()
		case <-anim.C:
			w.Invalidate()
		case e := <-w.Events():
			x++
			if x == 100 {
				runtime.ReadMemStats(ms)
				mallocs = ms.Mallocs
			}
			switch e := e.(type) {
			case system.DestroyEvent:
				os.Exit(0)
			case system.StageEvent:
				if e.Stage == system.StageRunning {
					go func() {
						updateIdBtns()
					}()
				}
			case system.FrameEvent:
				gtx := layout.NewContext(&ops, e)

				sysinset.Top = e.Insets.Top
				sysinset.Bottom = e.Insets.Bottom
				sysinset.Left = e.Insets.Left
				sysinset.Right = e.Insets.Right

				sysinset.Layout(gtx, func(gtx C) D {
					return margin.Layout(gtx, func(gtx C) D {
						margincs = gtx.Constraints
						c1 = layout.Rigid(func(gtx C) D {
							ct2 := layout.Rigid(func(gtx C) D {
								return plusBtn.Layout(gtx)
							})
							ct3 := layout.Rigid(func(gtx C) D {
								return dotsBtn.Layout(gtx)
							})
							ct1 := layout.Flexed(1.0, func(gtx C) D {
								gtx.Constraints.Min.X = gtx.Constraints.Max.X
								return title.Layout(gtx)
							})
							return titleflex.Layout(gtx, ct1, ct2, ct3)
						})

						return page(gtx)
					})
				})

				if dotsBtn.Clicked() {
					log(Info, "Configure")
					w.Invalidate()
					page = confPage
				}
				if plusBtn.Clicked() {
					log(Info, "Plus")
					w.Invalidate()
					insName, insValue = "", ""
					page = insertPage
				}
				e.Frame(gtx.Ops)
			default:
				handleEvent(e)
			}
			if x == 100 {
				x = 0
				runtime.ReadMemStats(ms)
				fmt.Printf("mallocs: %d\n", ms.Mallocs-mallocs)
			}
		}
	}
}