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
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
|
// 11 february 2014
package main
import (
"fmt"
"syscall"
"unsafe"
"sync"
)
type sysData struct {
cSysData
hwnd _HWND
children map[_HMENU]*sysData
nextChildID _HMENU
childrenLock sync.Mutex
shownAlready bool
}
type classData struct {
name string
style uint32
xstyle uint32
mkid bool
}
const controlstyle = _WS_CHILD | _WS_VISIBLE | _WS_TABSTOP
const controlxstyle = 0
var classTypes = [nctypes]*classData{
c_window: &classData{
style: _WS_OVERLAPPEDWINDOW,
xstyle: 0,
},
c_button: &classData{
name: "BUTTON",
style: _BS_PUSHBUTTON | controlstyle,
xstyle: 0 | controlxstyle,
},
}
func (s *sysData) addChild(chlid *sysData) _HMENU {
s.childrenLock.Lock()
defer s.childrenLock.Unlock()
s.nextChildID++ // start at 1
s.children[s.nextChildID] = child
return s.nextChildID
}
func (s *sysData) delChild(id _HMENU) {
s.childrenLock.Lock()
defer s.childrenLock.Unlock()
delete(s.children, id)
}
func (s *sysData) make(initText string, initWidth int, initHeight int, window *sysData) (err error) {
ret := make(chan uiret)
defer close(ret)
ct := classTypes[s.ctype]
classname := ct.name
cid := _HMENU(0)
pwin := uintptr(_NULL)
if window != nil { // this is a child control
cid = window.addChild(s)
pwin = uintptr(window.hwnd)
} else { // need a new class
n, err := registerStdWndClass(s)
if err != nil {
return r.err
}
classname = n
}
uitask <- &uimsg{
call: _createWindowEx,
p: []uintptr{
uintptr(ct.xstyle),
uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(classname))),
uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(initText))),
uintptr(ct.style),
uintptr(_CW_USEDEFAULT), // TODO
uintptr(_CW_USEDEFAULT),
uintptr(initWidth),
uintptr(initHeight),
pwin,
uintptr(cid),
uintptr(hInstance),
uintptr(_NULL),
},
ret: ret,
}
r := <-ret
if r.ret == 0 { // failure
if window != nil {
window.delChild(cid)
}
return r.err
}
s.hwnd = _HWND(r.ret)
return nil
}
var (
_updateWindow = user32.NewProc("UpdateWindow")
)
// if the object is a window, we need to do the following the first time
// ShowWindow(hwnd, nCmdShow);
// UpdateWindow(hwnd);
// otherwise we go ahead and show the object normally with SW_SHOW
func (s *sysData) show() (err error) {
if s.ctype != c_window { // don't do the init ShowWindow/UpdateWindow chain on non-windows
s.shownAlready = true
}
show := uintptr(_SW_SHOW)
if !s.shownAlready {
show = uintptr(nCmdShow)
}
ret := make(chan uiret)
defer close(ret)
// TODO figure out how to handle error
uitask <- &uimsg{
call: _showWindow,
p: []uintptr{uintptr(s.hwnd), show},
ret: ret,
}
<-ret
if !s.shownAlready {
uitask <- &uimsg{
call: _updateWindow,
p: []uintptr{uintptr(s.hwnd)},
ret: ret,
}
r := <-ret
if r.ret == 0 { // failure
return fmt.Errorf("error updating window for the first time: %v", r.err)
}
s.shownAlready = true
}
return nil
}
func (s *sysData) hide() (err error) {
ret := make(chan uiret)
defer close(ret)
// TODO figure out how to handle error
uitask <- &uimsg{
call: _showWindow,
p: []uintptr{uintptr(s.hwnd), _SW_HIDE},
ret: ret,
}
<-ret
return nil
}
func (s *sysData) setText(text string) error {
ret := make(chan uiret)
defer close(ret)
uitask <- &uimsg{
call: _setWindowText,
p: []uintptr{
uintptr(s.hwnd),
uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(text))),
},
ret: ret,
}
r := <-ret
if r.ret == 0 { // failure
return r.err
}
return nil
}
|
