package giowrap import ( "image/color" "log" "gioui.org/ui" "gioui.org/ui/app" "gioui.org/ui/input" "gioui.org/ui/layout" "gioui.org/ui/measure" "gioui.org/ui/text" "gioui.org/ui/f32" gdraw "gioui.org/ui/draw" "gioui.org/ui/gesture" "gioui.org/ui/pointer" ) type Context struct { Faces measure.Faces w *app.Window c *app.Config q input.Queue ops *ui.Ops cs layout.Constraints dims layout.Dimens extra map[string]interface{} } func NewContext(w *app.Window) Context { return Context{ w: w, ops: new(ui.Ops), q: w.Queue(), extra: make(map[string]interface{}), } } func (ctx Context) Reset(e app.DrawEvent) Context { ctx.c = &e.Config ctx.ops.Reset() ctx.cs = layout.RigidConstraints(e.Size) ctx.Faces.Reset(ctx.c) return ctx } func (ctx Context) Draw() { ctx.w.Draw(ctx.ops) } type Layout func(Context) Context func LayoutWithContext(ctx Context, ws ...Widget) Context { for _, w := range ws { ctx = w.Layout(ctx) } return ctx } type fWidget struct { l Layout } func NewfWidget(l Layout) fWidget { return fWidget{ l: l } } func (fw fWidget) Layout(ctx Context) Context { return fw.l(ctx) } type Widget interface { Layout(Context) Context } type WidgetCombinator func(...Widget) Widget type Label struct { l *text.Label } func NewLabel(face text.Face, t string, alignment text.Alignment) *Label { ret := &Label{} ret.l = &text.Label{ Face: face, Text: t, Alignment: alignment, } return ret } func (l *Label) Layout(ctx Context) Context { ctx.dims = l.l.Layout(ctx.ops, ctx.cs) return ctx } type Editor struct { e *text.Editor } func NewEditor(face text.Face, singleline bool) *Editor { ret := &Editor{} ret.e = &text.Editor{ Face: face, SingleLine: singleline } return ret } func (e *Editor) Layout(ctx Context) Context { ctx.dims = e.e.Layout(ctx.c, ctx.q, ctx.ops, ctx.cs) return ctx } func (e *Editor) Text() string { return e.e.Text() } func (e *Editor) SetText(s string) { e.e.SetText(s) } func (e *Editor) Focus() { e.e.Focus() } func Rgb(c uint32) color.RGBA { return Argb((0xff << 24) | c) } func Argb(c uint32) color.RGBA { return color.RGBA{A: uint8(c >> 24), R: uint8(c >> 16), G: uint8(c >> 8), B: uint8(c)} } type Flex WidgetCombinator func Flexible(v float32) Widget { return NewfWidget(func(ctx Context) Context { ctx.extra["Flexible"] = v return ctx }) } func NewFlex(axis layout.Axis, mainAxisAlignment layout.MainAxisAlignment, crossAxisAlignment layout.CrossAxisAlignment) Flex { f := layout.Flex{ Axis: axis, MainAxisAlignment: mainAxisAlignment, CrossAxisAlignment: crossAxisAlignment, } return func(ws ...Widget) Widget { return NewfWidget(func(ctx Context) Context { f.Init(ctx.ops, ctx.cs) fcs := make([]layout.FlexChild,len(ws)) for i, w := range ws { if v,ok := ctx.extra["Flexible"]; ok { switch v := v.(type) { case float32: ctx.cs = f.Flexible(v) default: log.Fatal("Type error") } } else { ctx.cs = f.Rigid() } ctx = w.Layout(ctx) fcs[i] = f.End(ctx.dims) } ctx.dims = f.Layout(fcs...) delete(ctx.extra, "Flexible") return ctx }) } } func NewInset(top, right, bottom, left ui.Value) WidgetCombinator { ins := layout.Inset{ Top: top, Right: right, Bottom: bottom, Left: left } return func(ws ...Widget) Widget { return NewfWidget(func(ctx Context) Context { ctx.cs = ins.Begin(ctx.c, ctx.ops, ctx.cs) var dims layout.Dimens for _, w := range ws { ctx = w.Layout(ctx) } ctx.dims = ins.End(dims) return ctx }) } } type Background struct { Color color.RGBA Radius ui.Value Inset layout.Inset macro ui.MacroOp } type Enclosure interface { Begin(Context) Context End(Context) Context } func Enclose(e Enclosure, ws ...Widget) Widget { return NewfWidget(func(ctx Context) Context { ctx = e.Begin(ctx) for _,w := range ws { ctx = w.Layout(ctx) } ctx = e.End(ctx) return ctx }) } func NewBackground(color color.RGBA, radius ui.Value) WidgetCombinator { bg := &Background{ Color: color, Radius: radius, Inset: layout.UniformInset(radius), // FIXME: need to be able to } // do math ops on Values return func(ws ...Widget) Widget { return Enclose(bg, ws...) } } func (bg *Background) Begin(ctx Context) Context { bg.macro.Record(ctx.ops) ctx.cs = bg.Inset.Begin(ctx.c, ctx.ops, ctx.cs) return ctx } func (bg *Background) End(ctx Context) Context { ctx.dims = bg.Inset.End(ctx.dims) bg.macro.Stop() //var stack ui.StackOp w, h := float32(ctx.dims.Size.X), float32(ctx.dims.Size.Y) if r := float32(ctx.c.Px(bg.Radius)); r > 0 { if r > w / 2 { r = w / 2 } if r > h / 2 { r = h / 2 } rrect(ctx.ops, w, h, r, r, r, r) } gdraw.ColorOp{Color: bg.Color}.Add(ctx.ops) gdraw.DrawOp{Rect: f32.Rectangle{Max: f32.Point{X: w, Y: h}}}.Add(ctx.ops) bg.macro.Add(ctx.ops) return ctx } // https://pomax.github.io/bezierinfo/#circles_cubic. func rrect(ops *ui.Ops, width, height, se, sw, nw, ne float32) { w, h := float32(width), float32(height) const c = 0.55228475 // 4*(sqrt(2)-1)/3 var b gdraw.PathBuilder b.Init(ops) b.Move(f32.Point{X: w, Y: h - se}) b.Cube(f32.Point{X: 0, Y: se * c}, f32.Point{X: -se + se*c, Y: se}, f32.Point{X: -se, Y: se}) // SE b.Line(f32.Point{X: sw - w + se, Y: 0}) b.Cube(f32.Point{X: -sw * c, Y: 0}, f32.Point{X: -sw, Y: -sw + sw*c}, f32.Point{X: -sw, Y: -sw}) // SW b.Line(f32.Point{X: 0, Y: nw - h + sw}) b.Cube(f32.Point{X: 0, Y: -nw * c}, f32.Point{X: nw - nw*c, Y: -nw}, f32.Point{X: nw, Y: -nw}) // NW b.Line(f32.Point{X: w - ne - nw, Y: 0}) b.Cube(f32.Point{X: ne * c, Y: 0}, f32.Point{X: ne, Y: ne - ne*c}, f32.Point{X: ne, Y: ne}) // NE b.End() } type cWidget struct { w Widget click *gesture.Click } func (w cWidget) Layout(ctx Context) Context { ctx = w.w.Layout(ctx) pointer.RectAreaOp{Size: ctx.dims.Size}.Add(ctx.ops) w.click.Add(ctx.ops) return ctx } func (w cWidget) Clicked(ctx Context) bool { for _,e := range w.click.Events(ctx.q) { if e.Type == gesture.TypeClick { return true } } return false } func Clickable(w Widget) cWidget { return cWidget{ w: w, click: new(gesture.Click) } }