package giowrap import ( "image" "image/color" //"log" "sync" "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 Extra struct { cur, max int sync.Mutex data []interface{} } var extra Extra func (e *Extra) New() int { e.Lock() if e.data == nil { e.data = make([]interface{},0) } ret := e.max e.max = e.max + 1 e.data = append(e.data,nil) e.Unlock() return ret } type Context struct { Faces measure.Faces w *app.Window c *app.Config q input.Queue ops *ui.Ops cs layout.Constraints dims layout.Dimens } func NewContext(w *app.Window) *Context { return &Context{ w: w, ops: new(ui.Ops), q: w.Queue(), } } func (ctx *Context) Reset(e app.DrawEvent) { ctx.c = &e.Config ctx.ops.Reset() ctx.cs = layout.RigidConstraints(e.Size) ctx.Faces.Reset(ctx.c) } func (ctx *Context) Draw() { ctx.w.Draw(ctx.ops) } type Layout func(*Context) type Widget interface { Layout(*Context) } type WidgetCombinator func(...Widget) Widget type Label struct { l *text.Label } type FaceOpt struct { face text.Face } func Face(x text.Face) FaceOpt { return FaceOpt { x } } type AlignOpt struct { alignment text.Alignment } func Align(x text.Alignment) AlignOpt { return AlignOpt { x } } type LabelOpts struct { FaceOpt AlignOpt } type LabelOption interface { DoLabelOption(*LabelOpts) } func (x FaceOpt) DoLabelOption(o *LabelOpts) { o.face = x.face } func (x AlignOpt) DoLabelOption(o *LabelOpts) { o.alignment = x.alignment } func NewLabel(t string, lops ...LabelOption) *Label { ret := &Label{} opts := &LabelOpts{} for _,o := range lops { o.DoLabelOption(opts) } ret.l = &text.Label{ Face: opts.face, Text: t, Alignment: opts.alignment, } return ret } func (l *Label) Layout(ctx *Context) { ctx.dims = l.l.Layout(ctx.ops, ctx.cs) } func (l *Label) SetText(t string) { l.l.Text = t } type Editor struct { e *text.Editor } type SinglelineOpt struct { singleline bool } func Singleline(x bool) SinglelineOpt { return SinglelineOpt{ x } } type EditorOpts struct { FaceOpt SinglelineOpt } type EditorOption interface { DoEditorOption(*EditorOpts) } func (x FaceOpt) DoEditorOption(o *EditorOpts) { o.face = x.face } func (x SinglelineOpt) DoEditorOption(o *EditorOpts) { o.singleline = x.singleline } func NewEditor(t string, eops ...EditorOption) *Editor { ret := &Editor{} opts := &EditorOpts{} for _,o := range eops { o.DoEditorOption(opts) } ret.e = &text.Editor{ Face: opts.face, SingleLine: opts.singleline } ret.SetText(t) return ret } func (e *Editor) Layout(ctx *Context) { ctx.dims = e.e.Layout(ctx.c, ctx.q, ctx.ops, ctx.cs) } 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() } type fWidget struct { l Layout } func NewfWidget(l Layout) fWidget { return fWidget{ l: l } } func (fw fWidget) Layout(ctx *Context) { fw.l(ctx) } type Stack WidgetCombinator func NewStack() Stack { s := layout.Stack{ Alignment: layout.Center } scs := make([]layout.StackChild,0) return func(ws ...Widget) Widget { return NewfWidget(func(ctx *Context) { s.Init(ctx.ops, ctx.cs) for _,w := range ws { ctx.cs = s.Rigid() w.Layout(ctx) scs = append(scs, s.End(ctx.dims)) } ctx.dims = s.Layout(scs...) scs = scs[0:0] }) } } type Flex WidgetCombinator // This "Widget" does nothing except set the Flexible field of a FlexOpts // struct within the Extra data structure func Flexible(v float32) Widget { return NewfWidget(func(ctx *Context) { extra.data[extra.cur].(*FlexOpts).flexible = v }) } func Rigid() Widget { return NewfWidget(func(ctx *Context) { extra.data[extra.cur].(*FlexOpts).flexible = 0 }) } type AxisOpt struct { axis layout.Axis } func Axis(x layout.Axis) AxisOpt { return AxisOpt{ x } } type MainAxisAlignmentOpt struct { mainAxisAlignment layout.MainAxisAlignment } func MainAxisAlignment(x layout.MainAxisAlignment) MainAxisAlignmentOpt { return MainAxisAlignmentOpt{ x } } type CrossAxisAlignmentOpt struct { crossAxisAlignment layout.CrossAxisAlignment } func CrossAxisAlignment(x layout.CrossAxisAlignment) CrossAxisAlignmentOpt { return CrossAxisAlignmentOpt{ x } } type FlexOpts struct { AxisOpt MainAxisAlignmentOpt CrossAxisAlignmentOpt flexible float32 } type FlexOption interface { DoFlexOption(*FlexOpts) } func (x AxisOpt) DoFlexOption(o *FlexOpts) { o.axis = x.axis } func (x MainAxisAlignmentOpt) DoFlexOption(o *FlexOpts) { o.mainAxisAlignment = x.mainAxisAlignment } func (x CrossAxisAlignmentOpt) DoFlexOption(o *FlexOpts) { o.crossAxisAlignment = x.crossAxisAlignment } // NewFlex returns a WidgetCombinator that wraps the layout.Flex element. func NewFlex(fos ...FlexOption) Flex { opts := &FlexOpts{} for _,o := range fos { o.DoFlexOption(opts) } f := layout.Flex{ Axis: opts.axis, MainAxisAlignment: opts.mainAxisAlignment, CrossAxisAlignment: opts.crossAxisAlignment, } index := extra.New() extra.data[index] = opts // do not call "make" inside the Layout function fcs := make([]layout.FlexChild,0) return func(ws ...Widget) Widget { return NewfWidget(func(ctx *Context) { // ensure child widgets write options to the right place extra.cur = index opts := extra.data[index].(*FlexOpts) f.Init(ctx.ops, ctx.cs) for _, w := range ws { if opts.flexible != 0 { ctx.cs = f.Flexible(opts.flexible) } else { ctx.cs = f.Rigid() } w.Layout(ctx) fcs = append(fcs, f.End(ctx.dims)) } ctx.dims = f.Layout(fcs...) fcs = fcs[0:0] // truncate }) } } type InsetOpts struct { top, right, bottom, left ui.Value } type InsetOption interface { DoInsetOption(*InsetOpts) } type TopOpt struct { top ui.Value } func Top(x ui.Value) TopOpt { return TopOpt{ x } } type RightOpt struct { right ui.Value } func Right(x ui.Value) RightOpt { return RightOpt{ x } } type BottomOpt struct { bottom ui.Value } func Bottom(x ui.Value) BottomOpt { return BottomOpt{ x } } type LeftOpt struct { left ui.Value } func Left(x ui.Value) LeftOpt { return LeftOpt{ x } } func (x TopOpt) DoInsetOption(o *InsetOpts) { o.top = x.top } func (x RightOpt) DoInsetOption(o *InsetOpts) { o.right = x.right } func (x BottomOpt) DoInsetOption(o *InsetOpts) { o.bottom = x.bottom } func (x LeftOpt) DoInsetOption(o *InsetOpts) { o.left = x.left } type SizeOpt struct { size ui.Value } func Size(x ui.Value) SizeOpt { return SizeOpt{ x } } func (x SizeOpt) DoInsetOption(o *InsetOpts) { o.top = x.size o.right = x.size o.bottom = x.size o.left = x.size } //NewInset returns a WidgetCombinator that wraps the layout.Inset element. func NewInset(insos ...InsetOption) WidgetCombinator { opts := &InsetOpts{} for _,o := range insos { o.DoInsetOption(opts) } ins := layout.Inset{ Top: opts.top, Right: opts.right, Bottom: opts.bottom, Left: opts.left } return func(ws ...Widget) Widget { return NewfWidget(func(ctx *Context) { ctx.cs = ins.Begin(ctx.c, ctx.ops, ctx.cs) for _, w := range ws { w.Layout(ctx) } ctx.dims = ins.End(ctx.dims) }) } } type Background struct { Color color.RGBA Radius ui.Value Inset layout.Inset macro ui.MacroOp } type Enclosure interface { Begin(*Context) End(*Context) } func Enclose(e Enclosure, ws ...Widget) Widget { return NewfWidget(func(ctx *Context) { e.Begin(ctx) for _,w := range ws { w.Layout(ctx) } e.End(ctx) }) } type BackgroundOpts struct { c color.RGBA radius ui.Value } type BackgroundOption interface { DoBackgroundOption(*BackgroundOpts) } type ColorOpt struct { c color.RGBA } func Color(x color.RGBA) ColorOpt { return ColorOpt{ x } } func (x ColorOpt) DoBackgroundOption(o *BackgroundOpts) { o.c = x.c } type RadiusOpt struct { radius ui.Value } func Radius(x ui.Value) RadiusOpt { return RadiusOpt { x } } func (x RadiusOpt) DoBackgroundOption(o *BackgroundOpts) { o.radius = x.radius } func NewBackground(bos ...BackgroundOption) WidgetCombinator { opts := &BackgroundOpts{} for _,o := range bos { o.DoBackgroundOption(opts) } bg := &Background{ Color: opts.c, Radius: opts.radius, Inset: layout.UniformInset(opts.radius), } return func(ws ...Widget) Widget { return Enclose(bg, ws...) } } func (bg *Background) Begin(ctx *Context) { bg.macro.Record(ctx.ops) ctx.cs = bg.Inset.Begin(ctx.c, ctx.ops, ctx.cs) } func (bg *Background) End(ctx *Context) { ctx.dims = bg.Inset.End(ctx.dims) bg.macro.Stop() var stack ui.StackOp stack.Push(ctx.ops) 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) stack.Pop() } // 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 Clickable interface { Widget Clicked(*Context) bool } //cWidget is a clickable Widget that provides the Clicked() method. type cWidget struct { w Widget click *gesture.Click } func (w cWidget) Layout(ctx *Context) { w.w.Layout(ctx) pointer.RectAreaOp{Size: ctx.dims.Size}.Add(ctx.ops) w.click.Add(ctx.ops) } func (w cWidget) Clicked(ctx *Context) bool { for _,e := range w.click.Events(ctx.q) { if e.Type == gesture.TypeClick { ctx.w.Invalidate() return true } } return false } //Clickable converts any Widget into a clickable Widget. func AsClickable(w Widget) cWidget { return cWidget{ w: w, click: new(gesture.Click) } } type Grid struct { Axis layout.Axis Cols int Height int macro ui.MacroOp ops *ui.Ops cs layout.Constraints mode gridMode row, col int } type GridChild struct { dims layout.Dimens macro ui.MacroOp } type gridMode uint8 const ( modeNone gridMode = iota modeBegun ) func (g *Grid) Init(ops *ui.Ops, cs layout.Constraints) layout.Constraints { g.mode = modeBegun g.ops = ops g.cs = cs g.row, g.col = 0, 0 cs.Height.Min = 0 if g.Height != 0 { cs.Height.Max = g.Height } cs.Width.Max = g.cs.Width.Max / g.Cols cs.Width.Min = cs.Width.Max return cs } func (g *Grid) Begin() { g.macro.Record(g.ops) } func (g *Grid) End(dims layout.Dimens) GridChild { if g.mode != modeBegun { panic("Must call Grid.Begin() before adding children.") } g.macro.Stop() return GridChild{ dims: dims, macro: g.macro } } func (g *Grid) Layout(cs ...GridChild) layout.Dimens { rowheight := 0 height := 0 var width float32 for _,c := range cs { var stack ui.StackOp stack.Push(g.ops) c.macro.Add(g.ops) stack.Pop() if c.dims.Size.Y > rowheight { rowheight = c.dims.Size.Y } g.col = g.col+1 x := float32(g.cs.Width.Max / g.Cols) ui.TransformOp{}.Offset(f32.Point{X: x}).Add(g.ops) width = width + x if g.col >= g.Cols { g.col = 0 ui.TransformOp{}.Offset(f32.Point{ X: -width, Y: float32(rowheight) }).Add(g.ops) g.row = g.row + 1 height = height + rowheight width = 0 rowheight = 0 } } if height == 0 { height = rowheight } g.mode = modeNone return layout.Dimens{ Size: image.Point{ g.cs.Width.Max, height } } } func toPointF(p image.Point) f32.Point { return f32.Point{X: float32(p.X), Y: float32(p.Y)} } func NewGrid(cols int) WidgetCombinator { g := &Grid{ Cols: cols } gcs := make([]GridChild,0) return func(ws ...Widget) Widget { return NewfWidget(func(ctx *Context) { cs := g.Init(ctx.ops, ctx.cs) ctx.cs = cs for _,w := range ws { g.Begin() w.Layout(ctx) ctx.cs = cs // widget layout can modify constraints... gcs = append(gcs,g.End(ctx.dims)) } ctx.dims = g.Layout(gcs...) gcs = gcs[0:0] }) } }