func ChildToParent(coord math.Point, from Control, to Parent) math.Point {
c := from
for {
p := c.Parent()
if p == nil {
panic(fmt.Errorf("Control detached: %s", Path(c)))
}
child := p.Children().Find(c)
if child == nil {
Dump(p)
panic(fmt.Errorf("Control's parent (%p %T) did not contain control (%p %T).", &p, p, &c, c))
}
coord = coord.Add(child.Offset)
if p == to {
return coord
}
if control, ok := p.(Control); ok {
c = control
} else {
Dump(p)
panic(fmt.Errorf("ChildToParent (%p %T) -> (%p %T) reached non-control parent (%p %T).",
&from, from, &to, to, &p, p))
}
}
}
func change(point *math.Point, direction string) {
switch direction {
case Top:
point.Y -= 20
case Right:
point.X += 20
case Bottom:
point.Y += 20
case Left:
point.X -= 20
}
}
func (i *Image) PixelAt(p math.Point) (math.Point, bool) {
ir := i.calculateDrawRect()
if tex := i.Texture(); tex != nil {
s := tex.SizePixels()
p = p.Sub(ir.Min).
ScaleX(float32(s.W) / float32(ir.W())).
ScaleY(float32(s.H) / float32(ir.H()))
if s.Rect().Contains(p) {
return p, true
}
}
return math.Point{X: -1, Y: -1}, false
}
func (t *DefaultTextBoxLine) PaintCarets(c gxui.Canvas) {
controller := t.textbox.controller
for i, cnt := 0, controller.SelectionCount(); i < cnt; i++ {
e := controller.Caret(i)
l := controller.LineIndex(e)
if l == t.lineIndex {
s := controller.LineStart(l)
m := t.outer.MeasureRunes(s, e)
top := math.Point{X: t.caretWidth + m.W, Y: 0}
bottom := top.Add(math.Point{X: 0, Y: t.Size().H})
t.outer.PaintCaret(c, top, bottom)
}
}
}
func (c *Container) ContainsPoint(p math.Point) bool {
if !c.outer.IsVisible() || !c.outer.Size().Rect().Contains(p) {
return false
}
for _, v := range c.children {
if v.Control.ContainsPoint(p.Sub(v.Offset)) {
return true
}
}
if c.IsMouseEventTarget() {
return true
}
return false
}
func draw(p Pendulum, canvas gxui.Canvas, x, y int) {
attachment := math.Point{X: ANIMATION_WIDTH/2 + x, Y: y}
phi := p.GetPhi()
ball := math.Point{X: x + ANIMATION_WIDTH/2 + math.Round(float32(l*omath.Sin(phi))), Y: y + math.Round(float32(l*omath.Cos(phi)))}
line := gxui.Polygon{gxui.PolygonVertex{attachment, 0}, gxui.PolygonVertex{ball, 0}}
canvas.DrawLines(line, gxui.DefaultPen)
m := math.Point{int(BALL_RADIUS), int(BALL_RADIUS)}
rect := math.Rect{ball.Sub(m), ball.Add(m)}
canvas.DrawRoundedRect(rect, BALL_RADIUS, BALL_RADIUS, BALL_RADIUS, BALL_RADIUS, gxui.TransparentPen, gxui.CreateBrush(gxui.Yellow))
}
func (f *font) Measure(fl *gxui.TextBlock) math.Size {
size := math.Size{W: 0, H: f.glyphMaxSizeDips.H}
var offset math.Point
for _, r := range fl.Runes {
if r == '\n' {
offset.X = 0
offset.Y += f.glyphMaxSizeDips.H
continue
}
offset.X += f.advanceDips(r)
size = size.Max(math.Size{W: offset.X, H: offset.Y + f.glyphMaxSizeDips.H})
}
return size
}
func TopControlsUnder(p math.Point, c Parent) ControlPointList {
children := c.Children()
for i := len(children) - 1; i >= 0; i-- {
child := children[i]
cp := p.Sub(child.Offset)
if child.Control.ContainsPoint(cp) {
l := ControlPointList{ControlPoint{child.Control, cp}}
if cc, ok := child.Control.(Parent); ok {
l = append(l, TopControlsUnder(cp, cc)...)
}
return l
}
}
return ControlPointList{}
}
func BreadcrumbsAt(p Container, pnt math.Point) string {
s := reflect.TypeOf(p).String()
for _, c := range p.Children() {
b := c.Control.Size().Rect().Offset(c.Offset)
if b.Contains(pnt) {
switch t := c.Control.(type) {
case Container:
return s + " > " + BreadcrumbsAt(t, pnt.Sub(c.Offset))
default:
return s + " > " + reflect.TypeOf(c.Control).String()
}
}
}
return s
}
func ControlsUnder(p math.Point, c Parent) ControlPointList {
toVisit := []ParentPoint{ParentPoint{c, p}}
l := ControlPointList{}
for len(toVisit) > 0 {
c = toVisit[0].C
p = toVisit[0].P
toVisit = toVisit[1:]
for _, child := range c.Children() {
cp := p.Sub(child.Offset)
if child.Control.ContainsPoint(cp) {
l = append(l, ControlPoint{child.Control, cp})
if cc, ok := child.Control.(Parent); ok {
toVisit = append(toVisit, ParentPoint{cc, cp})
}
}
}
}
return l
}
func (t *DefaultTextBoxLine) PaintSelections(c gxui.Canvas) {
controller := t.textbox.controller
ls, le := controller.LineStart(t.lineIndex), controller.LineEnd(t.lineIndex)
selections := controller.Selections()
if t.textbox.selectionDragging {
interval.Replace(&selections, t.textbox.selectionDrag)
}
interval.Visit(&selections, gxui.CreateTextSelection(ls, le, false), func(s, e uint64, _ int) {
if s < e {
x := t.outer.MeasureRunes(ls, int(s)).W
m := t.outer.MeasureRunes(int(s), int(e))
top := math.Point{X: t.caretWidth + x, Y: 0}
bottom := top.Add(m.Point())
t.outer.PaintSelection(c, top, bottom)
}
})
}
func WindowToChild(coord math.Point, to Control) math.Point {
c := to
for {
p := c.Parent()
if p == nil {
panic("Control's parent was nil")
}
child := p.Children().Find(c)
if child == nil {
Dump(p)
panic(fmt.Errorf("Control's parent (%p %T) did not contain control (%p %T).", &p, p, &c, c))
}
coord = coord.Sub(child.Offset)
if _, ok := p.(Window); ok {
return coord
}
c = p.(Control)
}
}
func (l *ScrollLayout) SetScrollOffset(scrollOffset math.Point) bool {
var cs math.Size
if l.child != nil {
cs = l.child.Control.Size()
}
s := l.innerSize
scrollOffset = scrollOffset.Min(cs.Sub(s).Point()).Max(math.Point{})
l.scrollBarX.Control.SetVisible(l.canScrollX && cs.W > s.W)
l.scrollBarY.Control.SetVisible(l.canScrollY && cs.H > s.H)
l.scrollBarX.Control.(gxui.ScrollBar).SetScrollPosition(l.scrollOffset.X, l.scrollOffset.X+s.W)
l.scrollBarY.Control.(gxui.ScrollBar).SetScrollPosition(l.scrollOffset.Y, l.scrollOffset.Y+s.H)
if l.scrollOffset != scrollOffset {
l.scrollOffset = scrollOffset
l.Relayout()
return true
}
return false
}
func (f *font) Layout(fl *gxui.TextBlock) (offsets []math.Point) {
sizeDips := math.Size{}
offsets = make([]math.Point, len(fl.Runes))
var offset math.Point
for i, r := range fl.Runes {
if r == '\n' {
offset.X = 0
offset.Y += f.glyphMaxSizeDips.H
continue
}
offsets[i] = offset
offset.X += f.advanceDips(r)
sizeDips = sizeDips.Max(math.Size{W: offset.X, H: offset.Y + f.glyphMaxSizeDips.H})
}
origin := f.align(fl.AlignRect, sizeDips, f.ascentDips, fl.H, fl.V)
for i, p := range offsets {
offsets[i] = p.Add(origin)
}
return offsets
}
func (l *LinearLayout) DesiredSize(min, max math.Size) math.Size {
if l.sizeMode.Fill() {
return max
}
bounds := min.Rect()
children := l.outer.Children()
horizontal := l.direction.Orientation().Horizontal()
offset := math.Point{X: 0, Y: 0}
for _, c := range children {
cs := c.Control.DesiredSize(math.ZeroSize, max)
cm := c.Control.Margin()
cb := cs.Expand(cm).Rect().Offset(offset)
if horizontal {
offset.X += cb.W()
} else {
offset.Y += cb.H()
}
bounds = bounds.Union(cb)
}
return bounds.Size().Expand(l.outer.Padding()).Clamp(min, max)
}
func (f *font) align(rect math.Rect, size math.Size, ascent int, h gxui.HorizontalAlignment, v gxui.VerticalAlignment) math.Point {
var origin math.Point
switch h {
case gxui.AlignLeft:
origin.X = rect.Min.X
case gxui.AlignCenter:
origin.X = rect.Mid().X - (size.W / 2)
case gxui.AlignRight:
origin.X = rect.Max.X - size.W
}
switch v {
case gxui.AlignTop:
origin.Y = rect.Min.Y + ascent
case gxui.AlignMiddle:
origin.Y = rect.Mid().Y - (size.H / 2) + ascent
case gxui.AlignBottom:
origin.Y = rect.Max.Y - size.H + ascent
}
return origin
}
func (s *ScrollBar) positionAt(p math.Point) int {
o := s.orientation
frac := float32(o.Major(p.XY())) / float32(o.Major(s.Size().WH()))
max := s.ScrollLimit()
return int(float32(max) * frac)
}
func ParentToChild(coord math.Point, from Parent, to Control) math.Point {
return coord.Sub(ChildToParent(math.ZeroPoint, to, from))
}