shiny/driver/windriver/window.go - exp - Git at Google

 // Copyright 2015 The Go Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.

 // +build windows

 package windriver

 // TODO: implement a back buffer.

 import (
 	"image"
 	"image/color"
 	"image/draw"
 	"sync"
 	"syscall"
 	"unsafe"

 	"golang.org/x/exp/shiny/driver/internal/pump"
 	"golang.org/x/exp/shiny/screen"
 	"golang.org/x/image/math/f64"
 	"golang.org/x/mobile/event/key"
 	"golang.org/x/mobile/event/mouse"
 	"golang.org/x/mobile/event/paint"
 	"golang.org/x/mobile/event/size"
 	"golang.org/x/mobile/geom"
 )

 var (
 	windowsMu sync.Mutex
 	windows   = map[syscall.Handle]*windowImpl{}

 	uploadsMu sync.Mutex
 	uploads   = map[uintptr]upload{}
 	uploadID  uintptr
 )

 type windowImpl struct {
 	hwnd syscall.Handle
 	pump pump.Pump
 }

 func newWindow(opts *screen.NewWindowOptions) (screen.Window, error) {
 	hwnd, err := createWindow()
 	if err != nil {
 		return nil, err
 	}

 	w := &windowImpl{
 		hwnd: hwnd,
 		pump: pump.Make(),
 	}

 	windowsMu.Lock()
 	windows[hwnd] = w
 	windowsMu.Unlock()

 	// Send a fake size event.
 	// Windows won't generate the WM_WINDOWPOSCHANGED
 	// we trigger a resize on for the initial size, so we have to do
 	// it ourselves. The example/basic program assumes it will
 	// receive a size.Event for the initial window size that isn't 0x0.
 	var r _RECT
 	// TODO(andlabs) error check
 	_GetClientRect(w.hwnd, &r)
 	sendSizeEvent(w.hwnd, &r)

 	return w, nil
 }

 func (w *windowImpl) Release() {
 	if w.hwnd == 0 { // already released?
 		return
 	}

 	windowsMu.Lock()
 	delete(windows, w.hwnd)
 	windowsMu.Unlock()

 	// TODO(andlabs): check for errors from this?
 	// TODO(andlabs): remove unsafe
 	_DestroyWindow(syscall.Handle(uintptr(unsafe.Pointer(w.hwnd))))
 	w.hwnd = 0
 	w.pump.Release()

 	// TODO(andlabs): what happens if we're still painting?
 }

 func (w *windowImpl) Events() <-chan interface{} { return w.pump.Events() }
 func (w *windowImpl) Send(event interface{})     { w.pump.Send(event) }

 func (w *windowImpl) Upload(dp image.Point, src screen.Buffer, sr image.Rectangle, sender screen.Sender) {
 	// Protect struct contents from being GCed
 	uploadsMu.Lock()
 	uploadID++
 	id := uploadID
 	uploads[id] = upload{
 		dp:       dp,
 		src:      src.(*bufferImpl),
 		sr:       sr,
 		sender:   sender,
 		uploader: w,
 	}
 	uploadsMu.Unlock()

 	_SendMessage(w.hwnd, msgUpload, id, 0)
 }

 type upload struct {
 	dp       image.Point
 	src      *bufferImpl
 	sr       image.Rectangle
 	sender   screen.Sender
 	uploader screen.Uploader
 }

 func handleUpload(hwnd syscall.Handle, id uintptr) error {
 	uploadsMu.Lock()
 	u := uploads[id]
 	delete(uploads, id)
 	uploadsMu.Unlock()

 	dc, err := _GetDC(hwnd)
 	if err != nil {
 		return err
 	}
 	defer _ReleaseDC(hwnd, dc)

 	u.src.preUpload(u.sender != nil)

 	// TODO: adjust if dp is outside dst bounds, or sr is outside src bounds.
 	err = blit(dc, _POINT{int32(u.dp.X), int32(u.dp.Y)}, u.src.hbitmap, &_RECT{
 		Left:   int32(u.sr.Min.X),
 		Top:    int32(u.sr.Min.Y),
 		Right:  int32(u.sr.Max.X),
 		Bottom: int32(u.sr.Max.Y),
 	})
 	go func() {
 		u.src.postUpload()
 		if u.sender != nil {
 			u.sender.Send(screen.UploadedEvent{
 				Buffer:   u.src,
 				Uploader: u.uploader,
 			})
 		}
 	}()
 	return err
 }

 func (w *windowImpl) Fill(dr image.Rectangle, src color.Color, op draw.Op) {
 	rect := _RECT{
 		Left:   int32(dr.Min.X),
 		Top:    int32(dr.Min.Y),
 		Right:  int32(dr.Max.X),
 		Bottom: int32(dr.Max.Y),
 	}
 	r, g, b, a := src.RGBA()
 	r >>= 8
 	g >>= 8
 	b >>= 8
 	a >>= 8
 	color := (a << 24) | (r << 16) | (g << 8) | b
 	msg := uint32(msgFillOver)
 	if op == draw.Src {
 		msg = msgFillSrc
 	}
 	// Note: this SendMessage won't return until after the fill
 	// completes, so using &rect is safe.
 	_SendMessage(w.hwnd, msg, uintptr(color), uintptr(unsafe.Pointer(&rect)))
 }

 func (w *windowImpl) Draw(src2dst f64.Aff3, src screen.Texture, sr image.Rectangle, op draw.Op, opts *screen.DrawOptions) {
 	// TODO
 }

 func (w *windowImpl) Publish() screen.PublishResult {
 	// TODO
 	return screen.PublishResult{}
 }

 func handlePaint(hwnd syscall.Handle) {
 	windowsMu.Lock()
 	w := windows[hwnd]
 	windowsMu.Unlock()

 	// TODO(andlabs) - this won't be necessary after the Go rewrite
 	// Windows sends spurious WM_PAINT messages at window
 	// creation.
 	if w == nil {
 		return
 	}

 	w.Send(paint.Event{}) // TODO(andlabs): fill struct field
 }

 func sendSizeEvent(hwnd syscall.Handle, r *_RECT) {
 	windowsMu.Lock()
 	w := windows[hwnd]
 	windowsMu.Unlock()

 	width := int(r.Right - r.Left)
 	height := int(r.Bottom - r.Top)
 	// TODO(andlabs): don't assume that PixelsPerPt == 1
 	w.Send(size.Event{
 		WidthPx:     width,
 		HeightPx:    height,
 		WidthPt:     geom.Pt(width),
 		HeightPt:    geom.Pt(height),
 		PixelsPerPt: 1,
 	})
 }

 func sendMouseEvent(hwnd syscall.Handle, uMsg uint32, x int32, y int32) {
 	var dir mouse.Direction
 	var button mouse.Button

 	windowsMu.Lock()
 	w := windows[hwnd]
 	windowsMu.Unlock()

 	switch uMsg {
 	case _WM_MOUSEMOVE:
 		dir = mouse.DirNone
 	case _WM_LBUTTONDOWN, _WM_MBUTTONDOWN, _WM_RBUTTONDOWN:
 		dir = mouse.DirPress
 	case _WM_LBUTTONUP, _WM_MBUTTONUP, _WM_RBUTTONUP:
 		dir = mouse.DirRelease
 	default:
 		panic("sendMouseEvent() called on non-mouse message")
 	}

 	switch uMsg {
 	case _WM_MOUSEMOVE:
 		button = mouse.ButtonNone
 	case _WM_LBUTTONDOWN, _WM_LBUTTONUP:
 		button = mouse.ButtonLeft
 	case _WM_MBUTTONDOWN, _WM_MBUTTONUP:
 		button = mouse.ButtonMiddle
 	case _WM_RBUTTONDOWN, _WM_RBUTTONUP:
 		button = mouse.ButtonRight
 	}
 	// TODO(andlabs): mouse wheel

 	w.Send(mouse.Event{
 		X:         float32(x),
 		Y:         float32(y),
 		Button:    button,
 		Modifiers: keyModifiers(),
 		Direction: dir,
 	})
 }

 // Precondition: this is called in immediate response to the message that triggered the event (so not after w.Send).
 func keyModifiers() (m key.Modifiers) {
 	down := func(x int32) bool {
 		// GetKeyState gets the key state at the time of the message, so this is what we want.
 		return _GetKeyState(x)&0x80 != 0
 	}

 	if down(_VK_CONTROL) {
 		m |= key.ModControl
 	}
 	if down(_VK_MENU) {
 		m |= key.ModAlt
 	}
 	if down(_VK_SHIFT) {
 		m |= key.ModShift
 	}
 	if down(_VK_LWIN) || down(_VK_RWIN) {
 		m |= key.ModMeta
 	}
 	return m
 }

 func windowWndProc(hwnd syscall.Handle, uMsg uint32, wParam uintptr, lParam uintptr) (lResult uintptr) {
 	switch uMsg {
 	case _WM_PAINT:
 		handlePaint(hwnd)
 		// defer to DefWindowProc; it will handle validation for us
 		return _DefWindowProc(hwnd, uMsg, wParam, lParam)
 	case _WM_WINDOWPOSCHANGED:
 		wp := (*_WINDOWPOS)(unsafe.Pointer(lParam))
 		if wp.Flags&_SWP_NOSIZE != 0 {
 			break
 		}
 		var r _RECT
 		if _GetClientRect(hwnd, &r) != nil {
 			// TODO(andlabs)
 		}
 		sendSizeEvent(hwnd, &r)
 		return 0
 	case _WM_MOUSEMOVE, _WM_LBUTTONDOWN:
 		// TODO(andlabs): call SetFocus()?
 	case _WM_LBUTTONUP, _WM_MBUTTONDOWN, _WM_MBUTTONUP, _WM_RBUTTONDOWN, _WM_RBUTTONUP:
 		sendMouseEvent(hwnd, uMsg, _GET_X_LPARAM(lParam), _GET_Y_LPARAM(lParam))
 		return 0
 	case _WM_KEYDOWN, _WM_KEYUP, _WM_SYSKEYDOWN, _WM_SYSKEYUP:
 		// TODO
 	case msgFillSrc:
 		// TODO error checks
 		dc, err := _GetDC(hwnd)
 		if err != nil {
 			// TODO handle errors
 			break
 		}
 		r := (*_RECT)(unsafe.Pointer(lParam))
 		// TODO handle errors
 		fillSrc(dc, r, _COLORREF(wParam))
 		_ReleaseDC(hwnd, dc)
 	case msgFillOver:
 		// TODO error checks
 		dc, err := _GetDC(hwnd)
 		if err != nil {
 			// TODO handle errors
 			break
 		}
 		r := (*_RECT)(unsafe.Pointer(lParam))
 		// TODO handle errors
 		fillOver(dc, r, _COLORREF(wParam))
 		_ReleaseDC(hwnd, dc)
 	case msgUpload:
 		err := handleUpload(hwnd, wParam)
 		if err != nil {
 			// TODO handle errors
 			break
 		}
 	}
 	return _DefWindowProc(hwnd, uMsg, wParam, lParam)
 }

 const windowClass = "shiny_Window"

 func initWindowClass() (err error) {
 	wcname, err := syscall.UTF16PtrFromString(windowClass)
 	if err != nil {
 		return err
 	}
 	_, err = _RegisterClass(&_WNDCLASS{
 		LpszClassName: wcname,
 		LpfnWndProc:   syscall.NewCallback(windowWndProc),
 		HIcon:         hDefaultIcon,
 		HCursor:       hDefaultCursor,
 		HInstance:     hThisInstance,
 		// TODO(andlabs): change this to something else? NULL? the hollow brush?
 		HbrBackground: syscall.Handle(_COLOR_BTNFACE + 1),
 	})
 	return err
 }

 func createWindow() (syscall.Handle, error) {
 	// TODO(brainman): convert windowClass to *uint16 once (in initWindowClass)
 	wcname, err := syscall.UTF16PtrFromString(windowClass)
 	if err != nil {
 		return 0, err
 	}
 	title, err := syscall.UTF16PtrFromString("Shiny Window")
 	if err != nil {
 		return 0, err
 	}
 	h, err := _CreateWindowEx(0,
 		wcname, title,
 		_WS_OVERLAPPEDWINDOW,
 		_CW_USEDEFAULT, _CW_USEDEFAULT,
 		_CW_USEDEFAULT, _CW_USEDEFAULT,
 		0, 0, hThisInstance, 0)
 	if err != nil {
 		return 0, err
 	}
 	// TODO(andlabs): use proper nCmdShow
 	_ShowWindow(h, _SW_SHOWDEFAULT)
 	// TODO(andlabs): call UpdateWindow()
 	return h, nil
 }
	// Copyright 2015 The Go Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style
	// license that can be found in the LICENSE file.

	// +build windows

	package windriver

	// TODO: implement a back buffer.

	import (
	"image"
	"image/color"
	"image/draw"
	"sync"
	"syscall"
	"unsafe"

	"golang.org/x/exp/shiny/driver/internal/pump"
	"golang.org/x/exp/shiny/screen"
	"golang.org/x/image/math/f64"
	"golang.org/x/mobile/event/key"
	"golang.org/x/mobile/event/mouse"
	"golang.org/x/mobile/event/paint"
	"golang.org/x/mobile/event/size"
	"golang.org/x/mobile/geom"
	)

	var (
	windowsMu sync.Mutex
	windows = map[syscall.Handle]*windowImpl{}

	uploadsMu sync.Mutex
	uploads = map[uintptr]upload{}
	uploadID uintptr
	)

	type windowImpl struct {
	hwnd syscall.Handle
	pump pump.Pump
	}

	func newWindow(opts *screen.NewWindowOptions) (screen.Window, error) {
	hwnd, err := createWindow()
	if err != nil {
	return nil, err
	}

	w := &windowImpl{
	hwnd: hwnd,
	pump: pump.Make(),
	}

	windowsMu.Lock()
	windows[hwnd] = w
	windowsMu.Unlock()

	// Send a fake size event.
	// Windows won't generate the WM_WINDOWPOSCHANGED
	// we trigger a resize on for the initial size, so we have to do
	// it ourselves. The example/basic program assumes it will
	// receive a size.Event for the initial window size that isn't 0x0.
	var r _RECT
	// TODO(andlabs) error check
	_GetClientRect(w.hwnd, &r)
	sendSizeEvent(w.hwnd, &r)

	return w, nil
	}

	func (w *windowImpl) Release() {
	if w.hwnd == 0 { // already released?
	return
	}

	windowsMu.Lock()
	delete(windows, w.hwnd)
	windowsMu.Unlock()

	// TODO(andlabs): check for errors from this?
	// TODO(andlabs): remove unsafe
	_DestroyWindow(syscall.Handle(uintptr(unsafe.Pointer(w.hwnd))))
	w.hwnd = 0
	w.pump.Release()

	// TODO(andlabs): what happens if we're still painting?
	}

	func (w *windowImpl) Events() <-chan interface{} { return w.pump.Events() }
	func (w *windowImpl) Send(event interface{}) { w.pump.Send(event) }

	func (w *windowImpl) Upload(dp image.Point, src screen.Buffer, sr image.Rectangle, sender screen.Sender) {
	// Protect struct contents from being GCed
	uploadsMu.Lock()
	uploadID++
	id := uploadID
	uploads[id] = upload{
	dp: dp,
	src: src.(*bufferImpl),
	sr: sr,
	sender: sender,
	uploader: w,
	}
	uploadsMu.Unlock()

	_SendMessage(w.hwnd, msgUpload, id, 0)
	}

	type upload struct {
	dp image.Point
	src *bufferImpl
	sr image.Rectangle
	sender screen.Sender
	uploader screen.Uploader
	}

	func handleUpload(hwnd syscall.Handle, id uintptr) error {
	uploadsMu.Lock()
	u := uploads[id]
	delete(uploads, id)
	uploadsMu.Unlock()

	dc, err := _GetDC(hwnd)
	if err != nil {
	return err
	}
	defer _ReleaseDC(hwnd, dc)

	u.src.preUpload(u.sender != nil)

	// TODO: adjust if dp is outside dst bounds, or sr is outside src bounds.
	err = blit(dc, _POINT{int32(u.dp.X), int32(u.dp.Y)}, u.src.hbitmap, &_RECT{
	Left: int32(u.sr.Min.X),
	Top: int32(u.sr.Min.Y),
	Right: int32(u.sr.Max.X),
	Bottom: int32(u.sr.Max.Y),
	})
	go func() {
	u.src.postUpload()
	if u.sender != nil {
	u.sender.Send(screen.UploadedEvent{
	Buffer: u.src,
	Uploader: u.uploader,
	})
	}
	}()
	return err
	}

	func (w *windowImpl) Fill(dr image.Rectangle, src color.Color, op draw.Op) {
	rect := _RECT{
	Left: int32(dr.Min.X),
	Top: int32(dr.Min.Y),
	Right: int32(dr.Max.X),
	Bottom: int32(dr.Max.Y),
	}
	r, g, b, a := src.RGBA()
	r >>= 8
	g >>= 8
	b >>= 8
	a >>= 8
	color := (a << 24) \| (r << 16) \| (g << 8) \| b
	msg := uint32(msgFillOver)
	if op == draw.Src {
	msg = msgFillSrc
	}
	// Note: this SendMessage won't return until after the fill
	// completes, so using &rect is safe.
	_SendMessage(w.hwnd, msg, uintptr(color), uintptr(unsafe.Pointer(&rect)))
	}

	func (w windowImpl) Draw(src2dst f64.Aff3, src screen.Texture, sr image.Rectangle, op draw.Op, opts screen.DrawOptions) {
	// TODO
	}

	func (w *windowImpl) Publish() screen.PublishResult {
	// TODO
	return screen.PublishResult{}
	}

	func handlePaint(hwnd syscall.Handle) {
	windowsMu.Lock()
	w := windows[hwnd]
	windowsMu.Unlock()

	// TODO(andlabs) - this won't be necessary after the Go rewrite
	// Windows sends spurious WM_PAINT messages at window
	// creation.
	if w == nil {
	return
	}

	w.Send(paint.Event{}) // TODO(andlabs): fill struct field
	}

	func sendSizeEvent(hwnd syscall.Handle, r *_RECT) {
	windowsMu.Lock()
	w := windows[hwnd]
	windowsMu.Unlock()

	width := int(r.Right - r.Left)
	height := int(r.Bottom - r.Top)
	// TODO(andlabs): don't assume that PixelsPerPt == 1
	w.Send(size.Event{
	WidthPx: width,
	HeightPx: height,
	WidthPt: geom.Pt(width),
	HeightPt: geom.Pt(height),
	PixelsPerPt: 1,
	})
	}

	func sendMouseEvent(hwnd syscall.Handle, uMsg uint32, x int32, y int32) {
	var dir mouse.Direction
	var button mouse.Button

	windowsMu.Lock()
	w := windows[hwnd]
	windowsMu.Unlock()

	switch uMsg {
	case _WM_MOUSEMOVE:
	dir = mouse.DirNone
	case _WM_LBUTTONDOWN, _WM_MBUTTONDOWN, _WM_RBUTTONDOWN:
	dir = mouse.DirPress
	case _WM_LBUTTONUP, _WM_MBUTTONUP, _WM_RBUTTONUP:
	dir = mouse.DirRelease
	default:
	panic("sendMouseEvent() called on non-mouse message")
	}

	switch uMsg {
	case _WM_MOUSEMOVE:
	button = mouse.ButtonNone
	case _WM_LBUTTONDOWN, _WM_LBUTTONUP:
	button = mouse.ButtonLeft
	case _WM_MBUTTONDOWN, _WM_MBUTTONUP:
	button = mouse.ButtonMiddle
	case _WM_RBUTTONDOWN, _WM_RBUTTONUP:
	button = mouse.ButtonRight
	}
	// TODO(andlabs): mouse wheel

	w.Send(mouse.Event{
	X: float32(x),
	Y: float32(y),
	Button: button,
	Modifiers: keyModifiers(),
	Direction: dir,
	})
	}

	// Precondition: this is called in immediate response to the message that triggered the event (so not after w.Send).
	func keyModifiers() (m key.Modifiers) {
	down := func(x int32) bool {
	// GetKeyState gets the key state at the time of the message, so this is what we want.
	return _GetKeyState(x)&0x80 != 0
	}

	if down(_VK_CONTROL) {
	m \|= key.ModControl
	}
	if down(_VK_MENU) {
	m \|= key.ModAlt
	}
	if down(_VK_SHIFT) {
	m \|= key.ModShift
	}
	if down(_VK_LWIN) \|\| down(_VK_RWIN) {
	m \|= key.ModMeta
	}
	return m
	}

	func windowWndProc(hwnd syscall.Handle, uMsg uint32, wParam uintptr, lParam uintptr) (lResult uintptr) {
	switch uMsg {
	case _WM_PAINT:
	handlePaint(hwnd)
	// defer to DefWindowProc; it will handle validation for us
	return _DefWindowProc(hwnd, uMsg, wParam, lParam)
	case _WM_WINDOWPOSCHANGED:
	wp := (*_WINDOWPOS)(unsafe.Pointer(lParam))
	if wp.Flags&_SWP_NOSIZE != 0 {
	break
	}
	var r _RECT
	if _GetClientRect(hwnd, &r) != nil {
	// TODO(andlabs)
	}
	sendSizeEvent(hwnd, &r)
	return 0
	case _WM_MOUSEMOVE, _WM_LBUTTONDOWN:
	// TODO(andlabs): call SetFocus()?
	case _WM_LBUTTONUP, _WM_MBUTTONDOWN, _WM_MBUTTONUP, _WM_RBUTTONDOWN, _WM_RBUTTONUP:
	sendMouseEvent(hwnd, uMsg, _GET_X_LPARAM(lParam), _GET_Y_LPARAM(lParam))
	return 0
	case _WM_KEYDOWN, _WM_KEYUP, _WM_SYSKEYDOWN, _WM_SYSKEYUP:
	// TODO
	case msgFillSrc:
	// TODO error checks
	dc, err := _GetDC(hwnd)
	if err != nil {
	// TODO handle errors
	break
	}
	r := (*_RECT)(unsafe.Pointer(lParam))
	// TODO handle errors
	fillSrc(dc, r, _COLORREF(wParam))
	_ReleaseDC(hwnd, dc)
	case msgFillOver:
	// TODO error checks
	dc, err := _GetDC(hwnd)
	if err != nil {
	// TODO handle errors
	break
	}
	r := (*_RECT)(unsafe.Pointer(lParam))
	// TODO handle errors
	fillOver(dc, r, _COLORREF(wParam))
	_ReleaseDC(hwnd, dc)
	case msgUpload:
	err := handleUpload(hwnd, wParam)
	if err != nil {
	// TODO handle errors
	break
	}
	}
	return _DefWindowProc(hwnd, uMsg, wParam, lParam)
	}

	const windowClass = "shiny_Window"

	func initWindowClass() (err error) {
	wcname, err := syscall.UTF16PtrFromString(windowClass)
	if err != nil {
	return err
	}
	_, err = _RegisterClass(&_WNDCLASS{
	LpszClassName: wcname,
	LpfnWndProc: syscall.NewCallback(windowWndProc),
	HIcon: hDefaultIcon,
	HCursor: hDefaultCursor,
	HInstance: hThisInstance,
	// TODO(andlabs): change this to something else? NULL? the hollow brush?
	HbrBackground: syscall.Handle(_COLOR_BTNFACE + 1),
	})
	return err
	}

	func createWindow() (syscall.Handle, error) {
	// TODO(brainman): convert windowClass to *uint16 once (in initWindowClass)
	wcname, err := syscall.UTF16PtrFromString(windowClass)
	if err != nil {
	return 0, err
	}
	title, err := syscall.UTF16PtrFromString("Shiny Window")
	if err != nil {
	return 0, err
	}
	h, err := _CreateWindowEx(0,
	wcname, title,
	_WS_OVERLAPPEDWINDOW,
	_CW_USEDEFAULT, _CW_USEDEFAULT,
	_CW_USEDEFAULT, _CW_USEDEFAULT,
	0, 0, hThisInstance, 0)
	if err != nil {
	return 0, err
	}
	// TODO(andlabs): use proper nCmdShow
	_ShowWindow(h, _SW_SHOWDEFAULT)
	// TODO(andlabs): call UpdateWindow()
	return h, nil
	}