316 lines
8.9 KiB
Go
316 lines
8.9 KiB
Go
// 24 march 2014
|
|
|
|
package ui
|
|
|
|
import (
|
|
"fmt"
|
|
"image"
|
|
"syscall"
|
|
"unsafe"
|
|
)
|
|
|
|
// #include "winapi_windows.h"
|
|
import "C"
|
|
|
|
type area struct {
|
|
*areabase
|
|
|
|
_hwnd C.HWND
|
|
|
|
clickCounter *clickCounter
|
|
}
|
|
|
|
func makeAreaWindowClass() error {
|
|
var errmsg *C.char
|
|
|
|
err := C.makeAreaWindowClass(&errmsg)
|
|
if err != 0 || errmsg != nil {
|
|
return fmt.Errorf("%s: %v", C.GoString(errmsg), syscall.Errno(err))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func newArea(ab *areabase) Area {
|
|
a := &area{
|
|
areabase: ab,
|
|
clickCounter: new(clickCounter),
|
|
}
|
|
a._hwnd = C.newArea(unsafe.Pointer(a))
|
|
a.SetSize(a.width, a.height)
|
|
return a
|
|
}
|
|
|
|
func (a *area) SetSize(width, height int) {
|
|
a.width = width
|
|
a.height = height
|
|
C.SendMessageW(a._hwnd, C.msgAreaSizeChanged, 0, 0)
|
|
}
|
|
|
|
func (a *area) RepaintAll() {
|
|
C.SendMessageW(a._hwnd, C.msgAreaRepaintAll, 0, 0)
|
|
}
|
|
|
|
//export doPaint
|
|
func doPaint(xrect *C.RECT, hscroll C.int, vscroll C.int, data unsafe.Pointer, dx *C.intptr_t, dy *C.intptr_t) unsafe.Pointer {
|
|
a := (*area)(data)
|
|
// both Windows RECT and Go image.Rect are point..point, so the following is correct
|
|
cliprect := image.Rect(int(xrect.left), int(xrect.top), int(xrect.right), int(xrect.bottom))
|
|
cliprect = cliprect.Add(image.Pt(int(hscroll), int(vscroll))) // adjust by scroll position
|
|
// make sure the cliprect doesn't fall outside the size of the Area
|
|
cliprect = cliprect.Intersect(image.Rect(0, 0, a.width, a.height))
|
|
if !cliprect.Empty() { // we have an update rect
|
|
i := a.handler.Paint(cliprect)
|
|
*dx = C.intptr_t(i.Rect.Dx())
|
|
*dy = C.intptr_t(i.Rect.Dy())
|
|
return unsafe.Pointer(i)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
//export dotoARGB
|
|
func dotoARGB(img unsafe.Pointer, ppvBits unsafe.Pointer) {
|
|
i := (*image.RGBA)(unsafe.Pointer(img))
|
|
// the bitmap Windows gives us has a stride == width
|
|
toARGB(i, uintptr(ppvBits), i.Rect.Dx() * 4)
|
|
}
|
|
|
|
//export areaWidthLONG
|
|
func areaWidthLONG(data unsafe.Pointer) C.LONG {
|
|
a := (*area)(data)
|
|
return C.LONG(a.width)
|
|
}
|
|
|
|
//export areaHeightLONG
|
|
func areaHeightLONG(data unsafe.Pointer) C.LONG {
|
|
a := (*area)(data)
|
|
return C.LONG(a.height)
|
|
}
|
|
|
|
func getModifiers() (m Modifiers) {
|
|
down := func(x C.int) bool {
|
|
// GetKeyState() gets the key state at the time of the message, so this is what we want
|
|
return (C.GetKeyState(x) & 0x80) != 0
|
|
}
|
|
|
|
if down(C.VK_CONTROL) {
|
|
m |= Ctrl
|
|
}
|
|
if down(C.VK_MENU) {
|
|
m |= Alt
|
|
}
|
|
if down(C.VK_SHIFT) {
|
|
m |= Shift
|
|
}
|
|
if down(C.VK_LWIN) || down(C.VK_RWIN) {
|
|
m |= Super
|
|
}
|
|
return m
|
|
}
|
|
|
|
//export finishAreaMouseEvent
|
|
func finishAreaMouseEvent(data unsafe.Pointer, cbutton C.DWORD, up C.BOOL, wParam C.WPARAM, xpos C.int, ypos C.int) {
|
|
var me MouseEvent
|
|
|
|
a := (*area)(data)
|
|
button := uint(cbutton)
|
|
me.Pos = image.Pt(int(xpos), int(ypos))
|
|
if !me.Pos.In(image.Rect(0, 0, a.width, a.height)) { // outside the actual Area; no event
|
|
return
|
|
}
|
|
if up != C.FALSE {
|
|
me.Up = button
|
|
} else if button != 0 { // don't run the click counter if the mouse was only moved
|
|
me.Down = button
|
|
// this returns a LONG, which is int32, but we don't need to worry about the signedness because for the same bit widths and two's complement arithmetic, s1-s2 == u1-u2 if bits(s1)==bits(s2) and bits(u1)==bits(u2) (and Windows requires two's complement: http://blogs.msdn.com/b/oldnewthing/archive/2005/05/27/422551.aspx)
|
|
// signedness isn't much of an issue for these calls anyway because http://stackoverflow.com/questions/24022225/what-are-the-sign-extension-rules-for-calling-windows-api-functions-stdcall-t and that we're only using unsigned values (think back to how you (didn't) handle signedness in assembly language) AND because of the above AND because the statistics below (time interval and width/height) really don't make sense if negative
|
|
time := C.GetMessageTime()
|
|
maxTime := C.GetDoubleClickTime()
|
|
// ignore zero returns and errors; MSDN says zero will be returned on error but that GetLastError() is meaningless
|
|
xdist := C.GetSystemMetrics(C.SM_CXDOUBLECLK)
|
|
ydist := C.GetSystemMetrics(C.SM_CYDOUBLECLK)
|
|
me.Count = a.clickCounter.click(button, me.Pos.X, me.Pos.Y,
|
|
uintptr(time), uintptr(maxTime), int(xdist/2), int(ydist/2))
|
|
}
|
|
// though wparam will contain control and shift state, let's use just one function to get modifiers for both keyboard and mouse events; it'll work the same anyway since we have to do this for alt and windows key (super)
|
|
me.Modifiers = getModifiers()
|
|
// TODO make wParam unsigned
|
|
// TODO XBUTTONs use something different
|
|
if button != 1 && (wParam & C.MK_LBUTTON) != 0 {
|
|
me.Held = append(me.Held, 1)
|
|
}
|
|
if button != 2 && (wParam & C.MK_MBUTTON) != 0 {
|
|
me.Held = append(me.Held, 2)
|
|
}
|
|
if button != 3 && (wParam & C.MK_RBUTTON) != 0 {
|
|
me.Held = append(me.Held, 3)
|
|
}
|
|
if button != 4 && (wParam & C.MK_XBUTTON1) != 0 {
|
|
me.Held = append(me.Held, 4)
|
|
}
|
|
if button != 5 && (wParam & C.MK_XBUTTON2) != 0 {
|
|
me.Held = append(me.Held, 5)
|
|
}
|
|
repaint := a.handler.Mouse(me)
|
|
if repaint {
|
|
a.RepaintAll()
|
|
}
|
|
}
|
|
|
|
//export areaKeyEvent
|
|
func areaKeyEvent(data unsafe.Pointer, up C.BOOL, wParam C.WPARAM, lParam C.LPARAM) {
|
|
var ke KeyEvent
|
|
|
|
a := (*area)(data)
|
|
lp := uint32(lParam) // to be safe
|
|
// the numeric keypad keys when Num Lock is off are considered left-hand keys as the separate navigation buttons were added later
|
|
// the numeric keypad enter, however, is a right-hand key because it has the same virtual-key code as the typewriter enter
|
|
righthand := (lp & 0x01000000) != 0
|
|
|
|
scancode := byte((lp >> 16) & 0xFF)
|
|
ke.Modifiers = getModifiers()
|
|
if extkey, ok := numpadextkeys[wParam]; ok && !righthand {
|
|
// the above is special handling for numpad keys to ignore the state of Num Lock and Shift; see http://blogs.msdn.com/b/oldnewthing/archive/2004/09/06/226045.aspx and https://github.com/glfw/glfw/blob/master/src/win32_window.c#L152
|
|
ke.ExtKey = extkey
|
|
} else if wParam == C.VK_RETURN && righthand {
|
|
ke.ExtKey = NEnter
|
|
} else if extkey, ok := extkeys[wParam]; ok {
|
|
ke.ExtKey = extkey
|
|
} else if mod, ok := modonlykeys[wParam]; ok {
|
|
ke.Modifier = mod
|
|
// don't include the modifier in ke.Modifiers
|
|
ke.Modifiers &^= mod
|
|
} else if xke, ok := fromScancode(uintptr(scancode)); ok {
|
|
// one of these will be nonzero
|
|
ke.Key = xke.Key
|
|
ke.ExtKey = xke.ExtKey
|
|
} else if ke.Modifiers == 0 {
|
|
// no key, extkey, or modifiers; do nothing
|
|
return
|
|
}
|
|
ke.Up = up != C.FALSE
|
|
// TODO repaint may no longer be needed
|
|
repaint := a.handler.Key(ke)
|
|
if repaint {
|
|
a.RepaintAll()
|
|
}
|
|
}
|
|
|
|
// all mappings come from GLFW - https://github.com/glfw/glfw/blob/master/src/win32_window.c#L152
|
|
var numpadextkeys = map[C.WPARAM]ExtKey{
|
|
C.VK_HOME: N7,
|
|
C.VK_UP: N8,
|
|
C.VK_PRIOR: N9,
|
|
C.VK_LEFT: N4,
|
|
C.VK_CLEAR: N5,
|
|
C.VK_RIGHT: N6,
|
|
C.VK_END: N1,
|
|
C.VK_DOWN: N2,
|
|
C.VK_NEXT: N3,
|
|
C.VK_INSERT: N0,
|
|
C.VK_DELETE: NDot,
|
|
}
|
|
|
|
var extkeys = map[C.WPARAM]ExtKey{
|
|
C.VK_ESCAPE: Escape,
|
|
C.VK_INSERT: Insert,
|
|
C.VK_DELETE: Delete,
|
|
C.VK_HOME: Home,
|
|
C.VK_END: End,
|
|
C.VK_PRIOR: PageUp,
|
|
C.VK_NEXT: PageDown,
|
|
C.VK_UP: Up,
|
|
C.VK_DOWN: Down,
|
|
C.VK_LEFT: Left,
|
|
C.VK_RIGHT: Right,
|
|
C.VK_F1: F1,
|
|
C.VK_F2: F2,
|
|
C.VK_F3: F3,
|
|
C.VK_F4: F4,
|
|
C.VK_F5: F5,
|
|
C.VK_F6: F6,
|
|
C.VK_F7: F7,
|
|
C.VK_F8: F8,
|
|
C.VK_F9: F9,
|
|
C.VK_F10: F10,
|
|
C.VK_F11: F11,
|
|
C.VK_F12: F12,
|
|
// numpad numeric keys and . are handled in events_notdarwin.go
|
|
// numpad enter is handled in code above
|
|
C.VK_ADD: NAdd,
|
|
C.VK_SUBTRACT: NSubtract,
|
|
C.VK_MULTIPLY: NMultiply,
|
|
C.VK_DIVIDE: NDivide,
|
|
}
|
|
|
|
// sanity check
|
|
func init() {
|
|
included := make([]bool, _nextkeys)
|
|
for _, v := range extkeys {
|
|
included[v] = true
|
|
}
|
|
for i := 1; i < int(_nextkeys); i++ {
|
|
if i >= int(N0) && i <= int(N9) { // skip numpad numbers, ., and enter
|
|
continue
|
|
}
|
|
if i == int(NDot) || i == int(NEnter) {
|
|
continue
|
|
}
|
|
if !included[i] {
|
|
panic(fmt.Errorf("error: not all ExtKeys defined on Windows (missing %d)", i))
|
|
}
|
|
}
|
|
}
|
|
|
|
var modonlykeys = map[C.WPARAM]Modifiers{
|
|
// even if the separate left/right aren't necessary, have them here anyway, just to be safe
|
|
C.VK_CONTROL: Ctrl,
|
|
C.VK_LCONTROL: Ctrl,
|
|
C.VK_RCONTROL: Ctrl,
|
|
C.VK_MENU: Alt,
|
|
C.VK_LMENU: Alt,
|
|
C.VK_RMENU: Alt,
|
|
C.VK_SHIFT: Shift,
|
|
C.VK_LSHIFT: Shift,
|
|
C.VK_RSHIFT: Shift,
|
|
// there's no combined Windows key virtual-key code as there is with the others
|
|
C.VK_LWIN: Super,
|
|
C.VK_RWIN: Super,
|
|
}
|
|
|
|
//export storeAreaHWND
|
|
func storeAreaHWND(data unsafe.Pointer, hwnd C.HWND) {
|
|
a := (*area)(data)
|
|
a._hwnd = hwnd
|
|
}
|
|
|
|
//export areaResetClickCounter
|
|
func areaResetClickCounter(data unsafe.Pointer) {
|
|
a := (*area)(data)
|
|
a.clickCounter.reset()
|
|
}
|
|
|
|
func (a *area) hwnd() C.HWND {
|
|
return a._hwnd
|
|
}
|
|
|
|
func (a *area) setParent(p *controlParent) {
|
|
basesetParent(a, p)
|
|
}
|
|
|
|
func (a *area) allocate(x int, y int, width int, height int, d *sizing) []*allocation {
|
|
return baseallocate(a, x, y, width, height, d)
|
|
}
|
|
|
|
func (a *area) preferredSize(d *sizing) (width, height int) {
|
|
// the preferred size of an Area is its size
|
|
return a.width, a.height
|
|
}
|
|
|
|
func (a *area) commitResize(c *allocation, d *sizing) {
|
|
basecommitResize(a, c, d)
|
|
}
|
|
|
|
func (a *area) getAuxResizeInfo(d *sizing) {
|
|
basegetAuxResizeInfo(a, d)
|
|
}
|