func (self window) run() {
var frame geom.Size
var density float64
defer self.window.Release()
defer close(self.events)
for {
v := self.window.NextEvent()
switch e := v.(type) {
default:
// This is none of the events that we know the mobile package should send,
// probably a custom event from the application so we simply forward it.
self.events <- v
case paint.Event:
gc := newGraphicContext(self.window)
self.events <- event.Redraw{
GC: gc,
Clip: geom.Rect{W: frame.W, H: frame.H},
External: e.External,
}
gc.join.Wait()
case size.Event:
w := float64(e.WidthPt)
h := float64(e.HeightPt)
d := float64(e.PixelsPerPt)
if w != frame.W || h != frame.H || d != density {
frame.W = w
frame.H = h
density = d
self.events <- event.ChangeScreen{Density: density}
self.events <- event.Resize{Size: frame}
}
case lifecycle.Event:
if e.To == lifecycle.StageDead {
self.events <- event.Close{}
return
}
switch e.Crosses(lifecycle.StageVisible) {
case lifecycle.CrossOn:
self.events <- event.Focus{Focused: true}
case lifecycle.CrossOff:
self.events <- event.Focus{Focused: false}
}
}
}
}
func (self UniformFillImageLayout) Layout(widget geom.Size, image geom.Size) (bounds geom.Rect) {
if r1, r2 := image.Ratio(), widget.Ratio(); r1 < r2 {
bounds.W = widget.W
bounds.H = widget.W / r1
bounds.Y = (widget.H / 2) - (bounds.H / 2)
} else if r1 > r2 {
bounds.W = widget.H * r1
bounds.H = widget.H
bounds.X = (widget.W / 2) - (bounds.W / 2)
} else {
bounds.W = widget.W
bounds.H = widget.H
}
return
}
func (self *MarginBox) PreferredSize(constraints geom.Size) geom.Size {
margin := self.Margin()
if self.content == nil {
return margin.Size()
}
if constraints.W >= 0 {
constraints.W = math.Max(0, constraints.W-margin.Width())
}
if constraints.H >= 0 {
constraints.H = math.Max(0, constraints.H-margin.Height())
}
return margin.GrowSize(self.content.PreferredSize(constraints))
}
func (self HorizontalLayout) PreferredSize(constraints geom.Size, widgets ...Widget) (size geom.Size) {
n := len(widgets)
if n == 0 {
return
}
constraints.W /= float64(n)
for _, w := range widgets {
s := w.PreferredSize(constraints)
size.W = math.Max(s.W, size.W)
size.H = math.Max(s.H, size.H)
}
size.W = (size.W * float64(n)) + (self.Spacing * float64(n-1))
return
}
func (self *window) run() {
var glctx gl.Context
var frame geom.Size
var scale float64
defer close(self.events)
for v := range self.app.Events() {
switch e := v.(type) {
default:
// This is none of the events that we know the mobile package should send,
// probably a custom event from the application so we simply forward it.
self.events <- v
case paint.Event:
if glctx != nil {
// Always clear the content before redrawing so we don't leak left overs
// of the video buffer.
glctx.ClearColor(0, 0, 0, 1)
glctx.Clear(gl.COLOR_BUFFER_BIT)
gc := newGraphicContext(self.app, glctx)
self.events <- event.Redraw{
GC: gc,
Clip: geom.Rect{W: frame.W, H: frame.H},
External: e.External,
}
gc.join.Wait()
}
case size.Event:
w := float64(e.WidthPt)
h := float64(e.HeightPt)
d := float64(e.PixelsPerPt)
if w != frame.W || h != frame.H || d != scale {
frame.W = w
frame.H = h
scale = d
self.events <- event.ChangeScreen{
Bounds: geom.Rect{W: frame.W, H: frame.H},
Scale: scale,
}
self.events <- event.Move{}
self.events <- event.Resize{
Size: frame,
}
}
case lifecycle.Event:
if e.To == lifecycle.StageDead {
self.events <- event.Close{}
return
}
switch e.Crosses(lifecycle.StageVisible) {
case lifecycle.CrossOn:
// The app doesn't send a paint event when it starts so we force
// it here to trigger the first drawing of the newly created
// window.
glctx = e.DrawContext.(gl.Context)
self.app.Send(paint.Event{External: true})
self.events <- event.Focus{Focused: true}
case lifecycle.CrossOff:
glctx = nil
self.events <- event.Focus{Focused: false}
}
}
}
// Unsure under which condition the events channel could get closed before a
// lifecycle event indicating the app is going away but just in case we send
// a close event before returning.
self.events <- event.Close{}
}
