313 lines
6.5 KiB
Go
313 lines
6.5 KiB
Go
// 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
|
|
altStyle uint32
|
|
appendMsg uintptr
|
|
insertAfterMsg uintptr
|
|
deleteMsg uintptr
|
|
}
|
|
|
|
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,
|
|
},
|
|
c_checkbox: &classData{
|
|
name: "BUTTON",
|
|
style: _BS_AUTOCHECKBOX | controlstyle,
|
|
xstyle: 0 | controlxstyle,
|
|
},
|
|
c_combobox: &classData{
|
|
name: "COMBOBOX",
|
|
style: _CBS_DROPDOWNLIST | controlstyle,
|
|
xstyle: 0 | controlxstyle,
|
|
altStyle: _CBS_DROPDOWN | _CBS_AUTOHSCROLL | controlstyle,
|
|
appendMsg: _CB_ADDSTRING,
|
|
insertAfterMsg: _CB_INSERTSTRING,
|
|
deleteMsg: _CB_DELETESTRING,
|
|
},
|
|
c_lineedit: &classData{
|
|
name: "EDIT",
|
|
style: _ES_AUTOHSCROLL | _WS_BORDER | controlstyle,
|
|
xstyle: 0 | controlxstyle,
|
|
},
|
|
c_label: &classData{
|
|
name: "STATIC",
|
|
style: _SS_NOPREFIX | controlstyle,
|
|
xstyle: 0 | controlxstyle,
|
|
},
|
|
c_listbox: &classData{
|
|
name: "LISTBOX",
|
|
style: 0 | controlstyle,
|
|
xstyle: 0 | controlxstyle,
|
|
altStyle: _LBS_EXTENDEDSEL | controlstyle,
|
|
appendMsg: _LB_ADDSTRING,
|
|
insertAfterMsg: _LB_INSERTSTRING,
|
|
deleteMsg: _LB_DELETESTRING,
|
|
},
|
|
}
|
|
|
|
func (s *sysData) addChild(child *sysData) _HMENU {
|
|
s.childrenLock.Lock()
|
|
defer s.childrenLock.Unlock()
|
|
s.nextChildID++ // start at 1
|
|
if s.children == nil {
|
|
s.children = map[_HMENU]*sysData{}
|
|
}
|
|
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)
|
|
}
|
|
|
|
// TODO adorn error messages with what stage failed?
|
|
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 err
|
|
}
|
|
classname = n
|
|
}
|
|
style := uintptr(ct.style)
|
|
if s.alternate {
|
|
style = uintptr(ct.altStyle)
|
|
}
|
|
uitask <- &uimsg{
|
|
call: _createWindowEx,
|
|
p: []uintptr{
|
|
uintptr(ct.xstyle),
|
|
uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(classname))),
|
|
uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(initText))),
|
|
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
|
|
}
|
|
|
|
func (s *sysData) setRect(x int, y int, width int, height int) error {
|
|
ret := make(chan uiret)
|
|
defer close(ret)
|
|
uitask <- &uimsg{
|
|
call: _moveWindow,
|
|
p: []uintptr{
|
|
uintptr(s.hwnd),
|
|
uintptr(x),
|
|
uintptr(y),
|
|
uintptr(width),
|
|
uintptr(height),
|
|
uintptr(_TRUE),
|
|
},
|
|
ret: ret,
|
|
}
|
|
r := <-ret
|
|
if r.ret == 0 { // failure
|
|
return r.err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// TODO figure out how to handle error
|
|
func (s *sysData) isChecked() (bool, error) {
|
|
ret := make(chan uiret)
|
|
defer close(ret)
|
|
uitask <- &uimsg{
|
|
call: _sendMessage,
|
|
p: []uintptr{
|
|
uintptr(s.hwnd),
|
|
uintptr(_BM_GETCHECK),
|
|
uintptr(0),
|
|
uintptr(0),
|
|
},
|
|
ret: ret,
|
|
}
|
|
r := <-ret
|
|
return r.ret == _BST_CHECKED, nil
|
|
}
|
|
|
|
// TODO adorn error messages with which part failed
|
|
func (s *sysData) text() (str string, err error) {
|
|
var tc []uint16
|
|
|
|
ret := make(chan uiret)
|
|
defer close(ret)
|
|
// TODO figure out how to handle errors
|
|
uitask <- &uimsg{
|
|
call: _sendMessage,
|
|
p: []uintptr{
|
|
uintptr(s.hwnd),
|
|
uintptr(_WM_GETTEXTLENGTH),
|
|
uintptr(0),
|
|
uintptr(0),
|
|
},
|
|
ret: ret,
|
|
}
|
|
r := <-ret
|
|
length := r.ret + 1 // terminating null
|
|
tc = make([]uint16, length)
|
|
// TODO figure out how to handle errors
|
|
uitask <- &uimsg{
|
|
call: _sendMessage,
|
|
p: []uintptr{
|
|
uintptr(s.hwnd),
|
|
uintptr(_WM_GETTEXT),
|
|
uintptr(_WPARAM(length)),
|
|
uintptr(_LPARAM(unsafe.Pointer(&tc[0]))),
|
|
},
|
|
ret: ret,
|
|
}
|
|
<-ret
|
|
// TODO check character count
|
|
return syscall.UTF16ToString(tc), nil
|
|
}
|
|
|
|
// TODO figure out how to handle errors
|
|
func (s *sysData) append(what string) (err error) {
|
|
ret := make(chan uiret)
|
|
defer close(ret)
|
|
uitask <- &uimsg{
|
|
call: _sendMessage,
|
|
p: []uintptr{
|
|
uintptr(s.hwnd),
|
|
uintptr(classTypes[s.ctype].appendMsg),
|
|
uintptr(_WPARAM(0)),
|
|
uintptr(_LPARAM(unsafe.Pointer(syscall.StringToUTF16Ptr(what)))),
|
|
},
|
|
ret: ret,
|
|
}
|
|
<-ret
|
|
// TODO error handling
|
|
return nil
|
|
}
|