passgo/cmd/passgo-gui/main.go

960 lines
22 KiB
Go
Raw Permalink Normal View History

2019-09-04 22:19:39 -04:00
// +build darwin linux
package main
import (
"fmt"
"io/ioutil"
"os"
2019-09-05 06:41:39 -04:00
"path"
"runtime"
"runtime/pprof"
"strconv"
2019-09-05 06:41:39 -04:00
"strings"
2019-09-04 22:19:39 -04:00
"sync"
"time"
2019-09-04 22:19:39 -04:00
"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"
2019-09-04 22:19:39 -04:00
"github.com/fsnotify/fsnotify"
"gopkg.in/yaml.v2"
2019-09-04 22:19:39 -04:00
2019-09-05 06:41:39 -04:00
"git.wow.st/gmp/passgo"
"git.wow.st/gmp/rand"
2019-09-04 22:19:39 -04:00
)
type (
D = layout.Dimensions
C = layout.Context
)
type conf struct {
2019-09-06 21:14:06 -04:00
StoreDir string
ClearDelay int
}
2019-09-04 22:19:39 -04:00
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)
2019-09-06 10:46:23 -04:00
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
2019-09-06 10:46:23 -04:00
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{})
2019-09-04 22:19:39 -04:00
updated = make(chan struct{})
chdir = make(chan struct{})
2019-09-06 11:43:14 -04:00
passch = make(chan []byte)
go func() {
log(Info,"passgo.Identities()")
passgo.Identities()
}()
2019-09-04 22:19:39 -04:00
go Updater()
2019-09-05 06:41:39 -04:00
log(Info, "Staring event loop")
2019-09-04 22:19:39 -04:00
go eventLoop()
app.Main()
2019-09-05 06:41:39 -04:00
log(Info, "Event loop returned")
2019-09-04 22:19:39 -04:00
}
var (
fontSize float32
collection []text.FontFace
2019-09-10 11:31:57 -04:00
confDir string
2019-09-06 21:14:06 -04:00
Config conf
l []passgo.Pass
mux sync.Mutex
store passgo.Store
reload chan struct{}
updated chan struct{}
2019-09-10 11:36:03 -04:00
chdir chan struct{}
2019-09-06 21:14:06 -04:00
passch chan []byte
th *material.Theme
2019-09-04 22:19:39 -04:00
)
func Updater() {
2019-11-20 15:48:56 -05:00
//time.Sleep(time.Second * 2)
2019-09-04 22:19:39 -04:00
update := func() {
fmt.Printf("update()\n")
2019-09-05 06:41:39 -04:00
ltmp, err := store.List()
2019-09-04 22:19:39 -04:00
if err != nil {
log(Info, err)
2019-09-04 22:19:39 -04:00
}
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)
2019-09-04 22:19:39 -04:00
for {
select {
case <-reload:
update()
2019-09-04 22:19:39 -04:00
case <-watcher.Events:
update()
case e := <-watcher.Errors:
2019-09-05 06:41:39 -04:00
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()
2019-09-04 22:19:39 -04:00
}
}
}
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)
}
}
2019-09-04 22:19:39 -04:00
func eventLoop() {
if collection == nil {
collection = gofont.Collection()
}
var ops op.Ops
th = material.NewTheme(collection)
th.TextSize = unit.Sp(fontSize)
2019-09-06 21:14:06 -04:00
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
2019-09-04 22:19:39 -04:00
sysinset := &layout.Inset{}
margin := layout.UniformInset(unit.Dp(10))
title := material.Body1(th, "passgo")
dotsBtn := &Button{
Size: unit.Sp(fontSize),
2019-09-06 10:46:23 -04:00
Label: "\xe2\x8b\xae",
Alignment: text.Middle,
2019-09-06 10:46:23 -04:00
Color: black,
Background: gray,
}
titleflex := &layout.Flex{Axis: layout.Horizontal}
flex := &layout.Flex{Axis: layout.Vertical}
2019-09-04 22:19:39 -04:00
lst := &layout.List{Axis: layout.Vertical}
2019-09-05 06:41:39 -04:00
passBtns := make([]*Button, 0)
pathnames := make([]string, 0)
copied := &Overlay{Size: unit.Sp(fontSize), Text: "copied to clipboard",
2019-09-06 10:46:23 -04:00
Color: black,
Background: darkgray,
2019-09-06 10:46:23 -04:00
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
2019-09-04 22:19:39 -04:00
2020-09-08 13:14:09 -04:00
FilterEd := &widget.Editor{SingleLine: true}
2019-09-04 22:19:39 -04:00
updateBtns := func() {
passBtns = passBtns[:0]
pathnames = pathnames[:0]
2020-09-08 13:14:09 -04:00
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)
2019-09-05 06:41:39 -04:00
s := strings.Repeat(" /", x.Level)
2020-09-08 13:14:09 -04:00
lbl := strings.Join([]string{s, n}, "")
if dirs[d] != true {
addd(x)
2019-09-05 06:41:39 -04:00
}
passBtns = append(passBtns, &Button{
Size: unit.Sp(fontSize),
2020-09-08 13:14:09 -04:00
Label: lbl,
Background: gray,
2019-09-04 22:19:39 -04:00
})
pathnames = append(pathnames, x.Pathname)
}
2020-09-08 13:14:09 -04:00
mux.Lock()
for _, x := range l {
if !x.Dir {
addf(x)
}
}
2019-09-04 22:19:39 -04:00
mux.Unlock()
}
idBtns := make([]*Button, 0)
updateIdBtns := func() {
log(Info,"passgo.Identities()")
ids, err := passgo.Identities()
if err != nil {
log(Info, err)
return
}
2019-09-10 11:36:03 -04:00
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),
2019-09-06 10:46:23 -04:00
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),
2019-09-06 10:46:23 -04:00
Label: "save",
Alignment: text.End,
Color: black,
Background: gray,
}
2019-09-06 10:52:27 -04:00
backBtn := &Button{
Size: unit.Sp(fontSize),
2019-09-06 10:52:27 -04:00
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 }
2019-09-06 11:43:14 -04:00
okBtn := &Button{
Size: unit.Sp(fontSize),
2019-09-06 11:43:14 -04:00
Label: "ok",
Alignment: text.End,
Color: black,
Background: gray,
}
plusBtn := &Button{
Size: unit.Sp(fontSize),
Label: "+",
Alignment: text.Middle,
Color: black,
Background: gray,
}
2020-09-17 20:18:20 -04:00
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")
2019-09-06 11:43:14 -04:00
anim := &time.Ticker{}
animating := false
animOn := func() {
2019-09-06 21:14:06 -04:00
log(Info, "animOn()")
anim = time.NewTicker(time.Second / 90)
animating = true
w.Invalidate()
}
animOff := func() {
2019-09-06 21:14:06 -04:00
log(Info, "animOff()")
anim.Stop()
animating = false
}
var listPage, idPage, insertPage, confirmPage, confPage, promptPage, page func(C) D
_ = idPage
2019-09-06 11:43:14 -04:00
prompt := func() []byte {
page = promptPage
promptEd.SetText("")
w.Invalidate()
return <-passch
}
2020-09-17 20:18:20 -04:00
lpf1 := &layout.Flex{Axis: layout.Horizontal}
listPage = func(gtx C) D {
2019-09-06 15:14:37 -04:00
// timing variables used for animation
fade1a, fade1b := 1.5, 2.0
start2 := float64(Config.ClearDelay)
2019-09-06 21:14:06 -04:00
fade2a, end := start2+1.5, start2+2.0
2019-09-06 15:14:37 -04:00
2020-09-08 13:14:09 -04:00
c2 := layout.Rigid(func(gtx C) D {
2020-09-17 20:18:20 -04:00
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)
2020-09-08 13:14:09 -04:00
})
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
}
2019-11-20 15:48:56 -05:00
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
})
2020-09-08 13:14:09 -04:00
ret := flex.Layout(gtx, c1, c2, c3)
x := time.Since(overlayStart).Seconds()
2019-09-06 15:14:37 -04:00
if x >= fade1b && x < start2 && animating {
animOff()
go func() {
2019-09-06 21:14:06 -04:00
time.Sleep(time.Millisecond * time.Duration((start2-x)*1000))
2019-09-06 15:14:37 -04:00
w.Invalidate()
2019-09-06 21:14:06 -04:00
time.Sleep(time.Millisecond * time.Duration((fade2a-start2)*1000))
2019-09-06 15:14:37 -04:00
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)
2019-09-06 15:14:37 -04:00
}
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)
})
2019-09-06 15:14:37 -04:00
}
if x > start2 && x < fade2a {
2019-09-06 21:14:06 -04:00
// animOff()
2019-09-06 15:14:37 -04:00
}
if animating && x > end {
animOff()
}
2020-09-08 13:14:09 -04:00
if len(FilterEd.Events()) > 0 {
updateBtns()
}
return ret
}
2019-11-20 15:48:56 -05:00
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)
})
2019-11-20 15:48:56 -05:00
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)
2019-11-20 15:48:56 -05:00
})
if updateBtn.Clicked() {
updateIdBtns()
w.Invalidate()
}
c4 = layout.Rigid(func(gtx C) D {
return material.Editor(th, idEd, "id").Layout(gtx)
2019-11-20 15:48:56 -05:00
})
for _, e := range idEd.Events() {
2019-11-20 15:48:56 -05:00
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)
2019-11-20 15:48:56 -05:00
})
if idSubmitBtn.Clicked() {
store.Id = idEd.Text()
page = listPage
}
c6 = layout.Rigid(func(gtx C) D {
return noidLabel.Layout(gtx)
2019-11-20 15:48:56 -05:00
})
} 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{} })
2019-11-20 15:48:56 -05:00
}
c7 = layout.Rigid(func(gtx C) D {
var ret D
2019-11-20 15:48:56 -05:00
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 {
2019-09-10 11:36:03 -04:00
log(Info, "Password exists")
page = confirmPage
w.Invalidate()
return ret
}
}
//Do not block the UI thread.
2019-11-20 15:48:56 -05:00
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
2019-11-20 15:48:56 -05:00
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)
2019-09-06 10:52:27 -04:00
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{}{}
}()
2019-09-06 10:52:27 -04:00
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() {
2019-09-06 11:43:14 -04:00
log(Info, "Ok")
go func() { // do not block UI thread
2019-09-06 21:14:06 -04:00
passch <- []byte(promptEd.Text())
2019-09-06 11:43:14 -04:00
}()
w.Invalidate()
2019-09-06 11:43:14 -04:00
page = listPage
}
if backBtn.Clicked() {
log(Info, "Back")
go func() {
passch <- nil // cancel prompt
}()
w.Invalidate()
2019-09-06 11:43:14 -04:00
page = listPage
}
return ret
2019-09-06 11:43:14 -04:00
}
page = listPage
ms := &runtime.MemStats{}
x := 0
var mallocs uint64
2019-09-05 06:41:39 -04:00
for {
select {
case <-updated:
log(Info, "UPDATE")
2019-09-04 22:19:39 -04:00
updateBtns()
2019-09-05 06:41:39 -04:00
w.Invalidate()
case <-anim.C:
w.Invalidate()
2019-09-05 06:41:39 -04:00
case e := <-w.Events():
x++
if x == 100 {
runtime.ReadMemStats(ms)
mallocs = ms.Mallocs
}
2019-09-04 22:19:39 -04:00
switch e := e.(type) {
case system.DestroyEvent:
2020-09-08 13:14:09 -04:00
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)
2019-09-04 22:19:39 -04:00
}
2019-09-05 06:41:39 -04:00
}
}
2019-09-04 22:19:39 -04:00
}