func ScreenToClientRect(hwnd w32.HWND, rect *w32.RECT) *Rect {
l, t, r, b := rect.Left, rect.Top, rect.Right, rect.Bottom
l, t = w32.ScreenToClient(hwnd, l, t)
r, b = w32.ScreenToClient(hwnd, r, b)
return NewRect(l, t, r, b)
}
func ScreenToClientRect(hwnd w32.HWND, rect *w32.RECT) *Rect {
l, t, r, b := rect.Left, rect.Top, rect.Right, rect.Bottom
l1, t1, _ := w32.ScreenToClient(hwnd, int(l), int(t))
r1, b1, _ := w32.ScreenToClient(hwnd, int(r), int(b))
return NewRect(l1, t1, r1, b1)
}
func (this *ControlBase) Pos() (x, y int) {
rect := w32.GetWindowRect(this.hwnd)
x = int(rect.Left)
y = int(rect.Top)
if !this.isForm && this.parent != nil {
x, y, _ = w32.ScreenToClient(this.parent.Handle(), x, y)
}
return
}
// WinEvent proccess a win32 event.
func winEvent(id w32.HWND, event uint32, wParam, lParam uintptr) uintptr {
w, ok := widgetTable[id]
if !ok {
return w32.DefWindowProc(id, event, wParam, lParam)
}
switch event {
case w32.WM_CHAR:
r := utf16.Decode([]uint16{uint16(loWord(uint32(wParam)))})
if len(r) == 0 {
break
}
key := r[0]
if key == 0 {
break
}
if (key == '\b') || (key == '\t') || (key == '\n') || (key == '\r') {
break
}
ev := sparta.KeyEvent{
Key: sparta.Key(key),
State: getState(),
}
x, y, _ := w32.GetCursorPos()
ev.Loc.X, ev.Loc.Y, _ = w32.ScreenToClient(id, x, y)
w.OnEvent(ev)
case w32.WM_CLOSE:
if w.Property(sparta.Parent) != nil {
break
}
w.OnEvent(sparta.CloseEvent{})
case w32.WM_KEYDOWN:
key := getKeyValue(wParam)
if key == 0 {
break
}
if (key & sparta.KeyNoChar) == 0 {
break
}
ev := sparta.KeyEvent{
Key: key,
State: getState(),
}
x, y, _ := w32.GetCursorPos()
ev.Loc.X, ev.Loc.Y, _ = w32.ScreenToClient(id, x, y)
w.OnEvent(ev)
case w32.WM_KEYUP:
key := getKeyValue(wParam)
if key == 0 {
break
}
ev := sparta.KeyEvent{
Key: -key,
State: getState(),
}
x, y, _ := w32.GetCursorPos()
ev.Loc.X, ev.Loc.Y, _ = w32.ScreenToClient(id, x, y)
w.OnEvent(ev)
case w32.WM_LBUTTONDOWN, w32.WM_RBUTTONDOWN, w32.WM_MBUTTONDOWN:
ev := sparta.MouseEvent{
Button: getButton(event),
State: getState(),
Loc: image.Pt(getXLParam(lParam), getYLParam(lParam)),
}
w.OnEvent(ev)
w.Focus()
case w32.WM_LBUTTONUP, w32.WM_RBUTTONUP, w32.WM_MBUTTONUP:
ev := sparta.MouseEvent{
Button: -getButton(event),
State: getState(),
Loc: image.Pt(getXLParam(lParam), getYLParam(lParam)),
}
w.OnEvent(ev)
case w32.WM_MOUSEMOVE:
ev := sparta.MouseEvent{
Loc: image.Pt(getXLParam(lParam), getYLParam(lParam)),
}
w.OnEvent(ev)
case w32.WM_MOUSEWHEEL:
ev := sparta.MouseEvent{
Button: sparta.MouseWheel,
}
if getWheelDeltaWParam(wParam) < 0 {
ev.Button = -sparta.MouseWheel
}
ev.Loc.X, ev.Loc.Y, _ = w32.ScreenToClient(id, getXLParam(lParam), getYLParam(lParam))
w = propagateWheel(w, ev.Loc)
w.OnEvent(ev)
case w32.WM_MOVE:
win := w.Window().(*window)
win.pos.X, win.pos.Y = int(loWord(uint32(lParam))), int(hiWord(uint32(lParam)))
case w32.WM_PAINT:
win := w.Window().(*window)
ps := &w32.PAINTSTRUCT{}
win.dc = w32.BeginPaint(id, ps)
win.isPaint = true
w32.SetBkMode(win.dc, w32.TRANSPARENT)
w32.SetBkColor(win.dc, win.back.color)
// "clear" the area
w32.SelectObject(win.dc, w32.HGDIOBJ(win.back.brush))
w32.SelectObject(win.dc, w32.HGDIOBJ(win.back.pen))
w32.Rectangle(win.dc, int(ps.RcPaint.Left), int(ps.RcPaint.Top), int(ps.RcPaint.Right), int(ps.RcPaint.Bottom))
w32.SelectObject(win.dc, w32.HGDIOBJ(win.fore.brush))
w32.SelectObject(win.dc, w32.HGDIOBJ(win.fore.pen))
w32.SelectObject(win.dc, w32.HGDIOBJ(winFont))
w32.SetTextColor(win.dc, win.fore.color)
win.curr = win.fore
ev := sparta.ExposeEvent{image.Rect(int(ps.RcPaint.Left), int(ps.RcPaint.Top), int(ps.RcPaint.Right), int(ps.RcPaint.Bottom))}
w.OnEvent(ev)
w32.EndPaint(id, ps)
win.isPaint = false
win.dc = 0
case w32.WM_SIZE:
win := w.Window().(*window)
ev := sparta.ConfigureEvent{image.Rect(win.pos.X, win.pos.Y, win.pos.X+int(loWord(uint32(lParam))), win.pos.Y+int(hiWord(uint32(lParam))))}
w.OnEvent(ev)
case w32.WM_USER:
src, ok := widgetTable[w32.HWND(wParam)]
if !ok {
src = nil
}
ev := sparta.CommandEvent{
Source: src,
Value: int(int32(lParam)),
}
w.OnEvent(ev)
default:
return w32.DefWindowProc(id, event, wParam, lParam)
}
return 0
}
func WndProc(hwnd w32.HWND, msg uint32, wparam, lparam uintptr) uintptr {
wnd := GetMsgHandler(hwnd)
if wnd == nil {
return uintptr(w32.DefWindowProc(hwnd, msg, wparam, lparam))
}
var rc uintptr
switch msg {
case w32.WM_ACTIVATE:
if wparam&0xffff != 0 {
/* This window has just been granted focus, so flag our internal
** key state as stale. We can't simply refresh our state because
** win32's GetKeyboardState isn't always accurate at this point
** in the event stream. */
wnd.keysStale = true
}
rc = w32.DefWindowProc(hwnd, msg, wparam, lparam)
case w32.WM_SHOWWINDOW:
w32.SetFocus(hwnd)
wnd.restoreCursor()
case w32.WM_LBUTTONDOWN, w32.WM_RBUTTONDOWN, w32.WM_MBUTTONDOWN:
wnd.button = wnd.button | buttonForDetail(msg)
var bpe wde.MouseDownEvent
bpe.Which = buttonForDetail(msg)
bpe.Where.X = int(lparam) & 0xFFFF
bpe.Where.Y = int(lparam>>16) & 0xFFFF
wnd.lastX = bpe.Where.X
wnd.lastY = bpe.Where.Y
wnd.events <- bpe
case w32.WM_LBUTTONUP, w32.WM_RBUTTONUP, w32.WM_MBUTTONUP:
wnd.button = wnd.button & ^buttonForDetail(msg)
var bpe wde.MouseUpEvent
bpe.Which = buttonForDetail(msg)
bpe.Where.X = int(lparam) & 0xFFFF
bpe.Where.Y = int(lparam>>16) & 0xFFFF
wnd.lastX = bpe.Where.X
wnd.lastY = bpe.Where.Y
wnd.events <- bpe
case w32.WM_MOUSEWHEEL:
var me wde.MouseEvent
screenX := int(lparam) & 0xFFFF
screenY := int(lparam>>16) & 0xFFFF
me.Where.X, me.Where.Y, _ = w32.ScreenToClient(wnd.hwnd, screenX, screenY)
button := wde.WheelDownButton
delta := int16((wparam >> 16) & 0xFFFF)
if delta > 0 {
button = wde.WheelUpButton
}
wnd.lastX = me.Where.X
wnd.lastX = me.Where.Y
wnd.events <- wde.MouseDownEvent{me, button}
wnd.events <- wde.MouseUpEvent{me, button}
case w32.WM_MOUSEMOVE:
var mme wde.MouseMovedEvent
mme.Where.X = int(lparam) & 0xFFFF
mme.Where.Y = int(lparam>>16) & 0xFFFF
if wnd.lastX != wnd.noX {
mme.From.X = int(wnd.lastX)
mme.From.Y = int(wnd.lastY)
} else {
mme.From.X = mme.Where.X
mme.From.Y = mme.Where.Y
}
wnd.lastX = mme.Where.X
wnd.lastY = mme.Where.Y
if !wnd.trackMouse {
var tme w32.TRACKMOUSEEVENT
tme.CbSize = uint32(unsafe.Sizeof(tme))
tme.DwFlags = w32.TME_LEAVE
tme.HwndTrack = hwnd
tme.DwHoverTime = w32.HOVER_DEFAULT
w32.TrackMouseEvent(&tme)
wnd.trackMouse = true
wnd.restoreCursor()
wnd.events <- wde.MouseEnteredEvent(mme)
} else {
if wnd.button == 0 {
wnd.events <- mme
} else {
var mde wde.MouseDraggedEvent
mde.MouseMovedEvent = mme
mde.Which = wnd.button
wnd.events <- mde
}
}
case w32.WM_MOUSELEAVE:
wnd.trackMouse = false
var wee wde.MouseExitedEvent
// TODO: get real position
wee.Where.Y = wnd.lastX
wee.Where.X = wnd.lastY
wnd.events <- wee
case w32.WM_SYSKEYDOWN, w32.WM_KEYDOWN:
translatable := w32.MapVirtualKeyEx(uint(wparam), w32.MAPVK_VK_TO_CHAR, w32.HKL(0))
wnd.keyDown = keyFromVirtualKeyCode(wparam)
wnd.keysDown[wnd.keyDown] = true
wnd.checkKeyState()
wnd.events <- wde.KeyDownEvent{wnd.keyDown}
if translatable == 0 {
kpe := wde.KeyTypedEvent{
wde.KeyEvent{wnd.keyDown},
"",
wnd.constructChord(),
}
wnd.events <- kpe
}
case w32.WM_SYSCHAR, w32.WM_CHAR:
glyph := syscall.UTF16ToString([]uint16{uint16(wparam)})
kpe := wde.KeyTypedEvent{
wde.KeyEvent{wnd.keyDown},
glyph,
wnd.constructChord(),
}
wnd.events <- kpe
case w32.WM_SYSKEYUP, w32.WM_KEYUP:
keyUp := keyFromVirtualKeyCode(wparam)
delete(wnd.keysDown, keyUp)
wnd.checkKeyState()
wnd.events <- wde.KeyUpEvent{
keyUp,
}
case w32.WM_SIZE:
width := int(lparam) & 0xFFFF
height := int(lparam>>16) & 0xFFFF
wnd.buffer = NewDIB(image.Rect(0, 0, width, height))
wnd.events <- wde.ResizeEvent{width, height}
rc = w32.DefWindowProc(hwnd, msg, wparam, lparam)
case w32.WM_PAINT:
wnd.Repaint()
rc = w32.DefWindowProc(hwnd, msg, wparam, lparam)
case WDEM_UI_THREAD:
f := <-wnd.uiTasks
f()
case w32.WM_CLOSE:
wnd.events <- wde.CloseEvent{}
case w32.WM_DESTROY:
w32.PostQuitMessage(0)
default:
rc = w32.DefWindowProc(hwnd, msg, wparam, lparam)
}
return rc
}
func ScreenToClientRect(hwnd w32.HWND, rect *w32.RECT) *Rect {
l, t, _ := w32.ScreenToClient(hwnd, int(rect.Left), int(rect.Top))
r, b, _ := w32.ScreenToClient(hwnd, int(rect.Right), int(rect.Bottom))
return NewRect(l, t, r, b)
}
