blob: 462a24b666bb1418fb9e6e28bc7718d052fbf2f3 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
|
// 6 july 2014
package ui
import (
"runtime"
"sync"
)
// Go initializes package ui.
// TODO write this bit
func Go() error {
runtime.LockOSThread()
if err := uiinit(); err != nil {
return err
}
go uitask()
uimsgloop()
return nil
}
// TODO Stop
// This is the ui main loop.
// It is spawned by Go as a goroutine.
func uitask() {
for {
select {
case req := <-Do:
// TODO foreign event
issue(req)
case <-stall: // wait for event to finish
<-stall // see below for information
}
}
}
// At each event, this is pulsed twice: once when the event begins, and once when the event ends.
// Do is not processed in between.
var stall = make(chan struct{})
type event struct {
// All events internally return bool; those that don't will be wrapped around to return a dummy value.
do func(c Doer) bool
lock sync.Mutex
}
// do should never be nil; TODO should we make setters panic instead?
func newEvent() *event {
return &event{
do: func(c Doer) bool {
return false
},
}
}
func (e *event) set(f func(Doer)) {
e.lock.Lock()
defer e.lock.Unlock()
if f == nil {
f = func(c Doer) {}
}
e.do = func(c Doer) bool {
f(c)
return false
}
}
func (e *event) setbool(f func(Doer) bool) {
e.lock.Lock()
defer e.lock.Unlock()
if f == nil {
f = func(c Doer) bool {
return false
}
}
e.do = f
}
// This is the common code for running an event.
// It runs on the main thread without a message pump; it provides its own.
func (e *event) fire() bool {
stall <- struct{}{} // enter event handler
c := make(Doer)
result := false
go func() {
e.lock.Lock()
defer e.lock.Unlock()
result = e.do(c)
close(c)
}()
for req := range c {
// note: this is perform, not issue!
// doevent runs on the main thread without a message pump!
perform(req)
}
// leave the event handler; leave it only after returning from an event handler so we must issue it like a normal Request
issue(&Request{
op: func() {
stall <- struct{}{}
},
// unfortunately, closing a nil channel causes a panic
// therefore, we have to make a dummy channel
// TODO add conditional checks to the request handler instead?
resp: make(chan interface{}),
})
return result
}
// Common code for performing a Request.
// This should run on the main thread.
// Implementations of issue() should call this.
func perform(req *Request) {
req.op()
close(req.resp)
}
|
