crunchy-rocks/draw2d
2
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Test win32 api

Browse source
This commit is contained in:
Laurent Le Goff 2012-04-19 16:49:55 +02:00
parent 492dcdf86f
commit 041bb7cbbb
8 changed files with 547 additions and 401 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
postscript/interpreter.go
View file

@ -44,6 +44,10 @@ func NewDictionary(prealloc int) Dictionary {
return make(Dictionary, prealloc) return make(Dictionary, prealloc)
} }
func (interpreter *Interpreter) SetGraphicContext(gc draw2d.GraphicContext) {
interpreter.gc = gc
}
func (interpreter *Interpreter) GetGraphicContext() draw2d.GraphicContext { func (interpreter *Interpreter) GetGraphicContext() draw2d.GraphicContext {
return interpreter.gc return interpreter.gc
} }

16
postscript/operators_graphics.go
View file

@ -80,7 +80,7 @@ func arc(interpreter *Interpreter) {
} }
func clippath(interpreter *Interpreter) { func clippath(interpreter *Interpreter) {
log.Printf("clippath not yet implemented") //log.Printf("clippath not yet implemented")
} }
func stroke(interpreter *Interpreter) { func stroke(interpreter *Interpreter) {
@ -198,9 +198,9 @@ func setcmybcolor(interpreter *Interpreter) {
} }
func setdash(interpreter *Interpreter) { func setdash(interpreter *Interpreter) {
offset := interpreter.PopInt() interpreter.PopInt() // offset
dash := interpreter.PopArray() interpreter.PopArray() // dash
log.Printf("setdash not yet implemented dash: %v, offset: %d \n", dash, offset) //log.Printf("setdash not yet implemented dash: %v, offset: %d \n", dash, offset)
} }
func setlinejoin(interpreter *Interpreter) { func setlinejoin(interpreter *Interpreter) {
@ -229,7 +229,7 @@ func setlinecap(interpreter *Interpreter) {
func setmiterlimit(interpreter *Interpreter) { func setmiterlimit(interpreter *Interpreter) {
interpreter.PopInt() interpreter.PopInt()
log.Printf("setmiterlimit not yet implemented") //log.Printf("setmiterlimit not yet implemented")
} }
func setlinewidth(interpreter *Interpreter) { func setlinewidth(interpreter *Interpreter) {
@ -237,7 +237,7 @@ func setlinewidth(interpreter *Interpreter) {
} }
func showpage(interpreter *Interpreter) { func showpage(interpreter *Interpreter) {
log.Printf("showpage may be an implementation specific, override show page to generate multi page images") //log.Printf("showpage may be an implementation specific, override show page to generate multi page images")
} }
func show(interpreter *Interpreter) { func show(interpreter *Interpreter) {
@ -275,12 +275,12 @@ func stringwidth(interpreter *Interpreter) {
func setflat(interpreter *Interpreter) { func setflat(interpreter *Interpreter) {
interpreter.Pop() interpreter.Pop()
log.Printf("setflat not yet implemented") //log.Printf("setflat not yet implemented")
} }
func currentflat(interpreter *Interpreter) { func currentflat(interpreter *Interpreter) {
interpreter.Push(1.0) interpreter.Push(1.0)
log.Printf("currentflat not yet implemented") //log.Printf("currentflat not yet implemented")
} }
// Coordinate System and Matrix operators // Coordinate System and Matrix operators

4
postscript/operators_misc.go
View file

@ -5,7 +5,7 @@
package postscript package postscript
import ( import (
"log" //"log"
) )
//proc bind proc Replace operator names in proc with operators; perform idiom recognition //proc bind proc Replace operator names in proc with operators; perform idiom recognition
@ -19,7 +19,7 @@ func bind(interpreter *Interpreter) {
v, _ := interpreter.FindValueInDictionaries(s) v, _ := interpreter.FindValueInDictionaries(s)
operator, isOperator := v.(Operator) operator, isOperator := v.(Operator)
if v == nil { if v == nil {
log.Printf("Can't find def: %s\n", s) // log.Printf("Can't find def: %s\n", s)
} }
if isOperator { if isOperator {
values[i] = operator values[i] = operator

224
wingui/winapi.go
View file

@ -1,154 +1,134 @@
// Copyright 2011 The Go Authors. All rights reserved. // Copyright 2011 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style // Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file. // license that can be found in the LICENSE file.
// +build windows
package wingui package wingui
import ( import (
"fmt" "syscall"
"os" "unsafe"
"syscall"
"unsafe"
) )
func abortf(format string, a ...interface{}) {
fmt.Fprintf(os.Stdout, format, a...)
os.Exit(1)
}
func loadDll(fname string) uint32 {
h, e := syscall.LoadLibrary(fname)
if e != 0 {
abortf("LoadLibrary(%s) failed with err=%d.\n", fname, e)
}
return h
}
func getSysProcAddr(m uint32, pname string) uintptr {
p, e := syscall.GetProcAddress(m, pname)
if e != 0 {
abortf("GetProcAddress(%s) failed with err=%d.\n", pname, e)
}
return uintptr(p)
}
type Wndclassex struct { type Wndclassex struct {
Size uint32 Size uint32
Style uint32 Style uint32
WndProc uintptr WndProc uintptr
ClsExtra int32 ClsExtra int32
WndExtra int32 WndExtra int32
Instance uint32 Instance syscall.Handle
Icon uint32 Icon syscall.Handle
Cursor uint32 Cursor syscall.Handle
Background uint32 Background syscall.Handle
MenuName *uint16 MenuName *uint16
ClassName *uint16 ClassName *uint16
IconSm uint32 IconSm syscall.Handle
} }
type Point struct { type Point struct {
X int32 X uintptr
Y int32 Y uintptr
} }
type Msg struct { type Msg struct {
Hwnd uint32 Hwnd syscall.Handle
Message uint32 Message uint32
Wparam int32 Wparam uintptr
Lparam int32 Lparam uintptr
Time uint32 Time uint32
Pt Point Pt Point
} }
const ( const (
// Window styles // Window styles
WS_OVERLAPPED = 0 WS_OVERLAPPED = 0
WS_POPUP = 0x80000000 WS_POPUP = 0x80000000
WS_CHILD = 0x40000000 WS_CHILD = 0x40000000
WS_MINIMIZE = 0x20000000 WS_MINIMIZE = 0x20000000
WS_VISIBLE = 0x10000000 WS_VISIBLE = 0x10000000
WS_DISABLED = 0x8000000 WS_DISABLED = 0x8000000
WS_CLIPSIBLINGS = 0x4000000 WS_CLIPSIBLINGS = 0x4000000
WS_CLIPCHILDREN = 0x2000000 WS_CLIPCHILDREN = 0x2000000
WS_MAXIMIZE = 0x1000000 WS_MAXIMIZE = 0x1000000
WS_CAPTION = WS_BORDER | WS_DLGFRAME WS_CAPTION = WS_BORDER | WS_DLGFRAME
WS_BORDER = 0x800000 WS_BORDER = 0x800000
WS_DLGFRAME = 0x400000 WS_DLGFRAME = 0x400000
WS_VSCROLL = 0x200000 WS_VSCROLL = 0x200000
WS_HSCROLL = 0x100000 WS_HSCROLL = 0x100000
WS_SYSMENU = 0x80000 WS_SYSMENU = 0x80000
WS_THICKFRAME = 0x40000 WS_THICKFRAME = 0x40000
WS_GROUP = 0x20000 WS_GROUP = 0x20000
WS_TABSTOP = 0x10000 WS_TABSTOP = 0x10000
WS_MINIMIZEBOX = 0x20000 WS_MINIMIZEBOX = 0x20000
WS_MAXIMIZEBOX = 0x10000 WS_MAXIMIZEBOX = 0x10000
WS_TILED = WS_OVERLAPPED WS_TILED = WS_OVERLAPPED
WS_ICONIC = WS_MINIMIZE WS_ICONIC = WS_MINIMIZE
WS_SIZEBOX = WS_THICKFRAME WS_SIZEBOX = WS_THICKFRAME
// Common Window Styles // Common Window Styles
WS_OVERLAPPEDWINDOW = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX WS_OVERLAPPEDWINDOW = WS_OVERLAPPED | WS_CAPTION | WS_SYSMENU | WS_THICKFRAME | WS_MINIMIZEBOX | WS_MAXIMIZEBOX
WS_TILEDWINDOW = WS_OVERLAPPEDWINDOW WS_TILEDWINDOW = WS_OVERLAPPEDWINDOW
WS_POPUPWINDOW = WS_POPUP | WS_BORDER | WS_SYSMENU WS_POPUPWINDOW = WS_POPUP | WS_BORDER | WS_SYSMENU
WS_CHILDWINDOW = WS_CHILD WS_CHILDWINDOW = WS_CHILD
WS_EX_CLIENTEDGE = 0x200 WS_EX_CLIENTEDGE = 0x200
// Some windows messages // Some windows messages
WM_CREATE = 1 WM_CREATE = 1
WM_DESTROY = 2 WM_DESTROY = 2
WM_CLOSE = 16 WM_CLOSE = 16
WM_COMMAND = 273 WM_COMMAND = 273
// Some button control styles // Some button control styles
BS_DEFPUSHBUTTON = 1 BS_DEFPUSHBUTTON = 1
// Some colour constants // Some color constants
COLOR_WINDOW = 5 COLOR_WINDOW = 5
COLOR_BTNFACE = 15 COLOR_BTNFACE = 15
// Default window position // Default window position
CW_USEDEFAULT = 0x80000000 - 0x100000000 CW_USEDEFAULT = 0x80000000 - 0x100000000
// Show window default style // Show window default style
SW_SHOWDEFAULT = 10 SW_SHOWDEFAULT = 10
) )
var ( var (
// Some globaly known cusrors // Some globally known cursors
IDC_ARROW = MakeIntResource(32512) IDC_ARROW = MakeIntResource(32512)
IDC_IBEAM = MakeIntResource(32513) IDC_IBEAM = MakeIntResource(32513)
IDC_WAIT = MakeIntResource(32514) IDC_WAIT = MakeIntResource(32514)
IDC_CROSS = MakeIntResource(32515) IDC_CROSS = MakeIntResource(32515)
// Some globaly known icons // Some globally known icons
IDI_APPLICATION = MakeIntResource(32512) IDI_APPLICATION = MakeIntResource(32512)
IDI_HAND = MakeIntResource(32513) IDI_HAND = MakeIntResource(32513)
IDI_QUESTION = MakeIntResource(32514) IDI_QUESTION = MakeIntResource(32514)
IDI_EXCLAMATION = MakeIntResource(32515) IDI_EXCLAMATION = MakeIntResource(32515)
IDI_ASTERISK = MakeIntResource(32516) IDI_ASTERISK = MakeIntResource(32516)
IDI_WINLOGO = MakeIntResource(32517) IDI_WINLOGO = MakeIntResource(32517)
IDI_WARNING = IDI_EXCLAMATION IDI_WARNING = IDI_EXCLAMATION
IDI_ERROR = IDI_HAND IDI_ERROR = IDI_HAND
IDI_INFORMATION = IDI_ASTERISK IDI_INFORMATION = IDI_ASTERISK
) )
//sys GetModuleHandle(modname *uint16) (handle uint32, errno int) = GetModuleHandleW //sys GetModuleHandle(modname *uint16) (handle syscall.Handle, err error) = GetModuleHandleW
//sys RegisterClassEx(wndclass *Wndclassex) (atom uint16, errno int) = user32.RegisterClassExW //sys RegisterClassEx(wndclass *Wndclassex) (atom uint16, err error) = user32.RegisterClassExW
//sys CreateWindowEx(exstyle uint32, classname *uint16, windowname *uint16, style uint32, x int32, y int32, width int32, height int32, wndparent uint32, menu uint32, instance uint32, param uintptr) (hwnd uint32, errno int) = user32.CreateWindowExW //sys CreateWindowEx(exstyle uint32, classname *uint16, windowname *uint16, style uint32, x int32, y int32, width int32, height int32, wndparent syscall.Handle, menu syscall.Handle, instance syscall.Handle, param uintptr) (hwnd syscall.Handle, err error) = user32.CreateWindowExW
//sys DefWindowProc(hwnd uint32, msg uint32, wparam int32, lparam int32) (lresult int32) = user32.DefWindowProcW //sys DefWindowProc(hwnd syscall.Handle, msg uint32, wparam uintptr, lparam uintptr) (lresult uintptr) = user32.DefWindowProcW
//sys DestroyWindow(hwnd uint32) (errno int) = user32.DestroyWindow //sys DestroyWindow(hwnd syscall.Handle) (err error) = user32.DestroyWindow
//sys PostQuitMessage(exitcode int32) = user32.PostQuitMessage //sys PostQuitMessage(exitcode int32) = user32.PostQuitMessage
//sys ShowWindow(hwnd uint32, cmdshow int32) (wasvisible bool) = user32.ShowWindow //sys ShowWindow(hwnd syscall.Handle, cmdshow int32) (wasvisible bool) = user32.ShowWindow
//sys UpdateWindow(hwnd uint32) (errno int) = user32.UpdateWindow //sys UpdateWindow(hwnd syscall.Handle) (err error) = user32.UpdateWindow
//sys GetMessage(msg *Msg, hwnd uint32, MsgFilterMin uint32, MsgFilterMax uint32) (ret int32, errno int) [failretval==-1] = user32.GetMessageW //sys GetMessage(msg *Msg, hwnd syscall.Handle, MsgFilterMin uint32, MsgFilterMax uint32) (ret int32, err error) [failretval==-1] = user32.GetMessageW
//sys TranslateMessage(msg *Msg) (done bool) = user32.TranslateMessage //sys TranslateMessage(msg *Msg) (done bool) = user32.TranslateMessage
//sys DispatchMessage(msg *Msg) (ret int32) = user32.DispatchMessageW //sys DispatchMessage(msg *Msg) (ret int32) = user32.DispatchMessageW
//sys LoadIcon(instance uint32, iconname *uint16) (icon uint32, errno int) = user32.LoadIconW //sys LoadIcon(instance syscall.Handle, iconname *uint16) (icon syscall.Handle, err error) = user32.LoadIconW
//sys LoadCursor(instance uint32, cursorname *uint16) (cursor uint32, errno int) = user32.LoadCursorW //sys LoadCursor(instance syscall.Handle, cursorname *uint16) (cursor syscall.Handle, err error) = user32.LoadCursorW
//sys SetCursor(cursor uint32) (precursor uint32, errno int) = user32.SetCursor //sys SetCursor(cursor syscall.Handle) (precursor syscall.Handle, err error) = user32.SetCursor
//sys SendMessage(hwnd uint32, msg uint32, wparam int32, lparam int32) (lresult int32) = user32.SendMessageW //sys SendMessage(hwnd syscall.Handle, msg uint32, wparam uintptr, lparam uintptr) (lresult uintptr) = user32.SendMessageW
//sys PostMessage(hwnd uint32, msg uint32, wparam int32, lparam int32) (errno int) = user32.PostMessageW //sys PostMessage(hwnd syscall.Handle, msg uint32, wparam uintptr, lparam uintptr) (err error) = user32.PostMessageW
func MakeIntResource(id uint16) *uint16 { func MakeIntResource(id uint16) *uint16 {
return (*uint16)(unsafe.Pointer(uintptr(id))) return (*uint16)(unsafe.Pointer(uintptr(id)))
} }

87
wingui/wingdi.go
View file

@ -9,11 +9,26 @@ const (
WM_PAINT = 15 WM_PAINT = 15
BI_RGB = 0 BI_RGB = 0
BI_BITFIELDS = 3
DIB_PAL_COLORS = 1 DIB_PAL_COLORS = 1
DIB_RGB_COLORS = 0 DIB_RGB_COLORS = 0
BLACKNESS = 0x42
DSTINVERT = 0x550009
MERGECOPY = 0xC000CA
MERGEPAINT = 0xBB0226
NOTSRCCOPY = 0x330008
NOTSRCERASE = 0x1100A6
PATCOPY = 0xF00021
PATINVERT = 0x5A0049
PATPAINT = 0xFB0A09
SRCAND = 0x8800C6
SRCCOPY = 0xCC0020 SRCCOPY = 0xCC0020
SRCERASE = 0x440328
SRCINVERT = 0x660046
SRCPAINT = 0xEE0086
WHITENESS = 0xFF0062
) )
type RECT struct { type RECT struct {
@ -24,7 +39,7 @@ type RECT struct {
} }
type PAINTSTRUCT struct { type PAINTSTRUCT struct {
HDC uint32 HDC syscall.Handle
Erase int32 // bool Erase int32 // bool
RcPaint RECT RcPaint RECT
Restore int32 // bool Restore int32 // bool
@ -69,64 +84,64 @@ type RGBQUAD struct {
} }
var ( var (
modgdi32 = loadDll("gdi32.dll") modgdi32 = syscall.NewLazyDLL("gdi32.dll")
procGetDC = getSysProcAddr(moduser32, "GetDC") procGetDC = moduser32.NewProc("GetDC")
procCreateCompatibleDC = getSysProcAddr(modgdi32, "CreateCompatibleDC") procCreateCompatibleDC = modgdi32.NewProc("CreateCompatibleDC")
procGetObject = getSysProcAddr(modgdi32, "GetObjectW") procGetObject = modgdi32.NewProc("GetObjectW")
procSelectObject = getSysProcAddr(modgdi32, "SelectObject") procSelectObject = modgdi32.NewProc("SelectObject")
procBeginPaint = getSysProcAddr(moduser32, "BeginPaint") procBeginPaint = moduser32.NewProc("BeginPaint")
procEndPaint = getSysProcAddr(moduser32, "EndPaint") procEndPaint = moduser32.NewProc("EndPaint")
procCreateCompatibleBitmap = getSysProcAddr(modgdi32, "CreateCompatibleBitmap") procCreateCompatibleBitmap = modgdi32.NewProc("CreateCompatibleBitmap")
procCreateDIBSection = getSysProcAddr(modgdi32, "CreateDIBSection") procCreateDIBSection = modgdi32.NewProc("CreateDIBSection")
procBitBlt = getSysProcAddr(modgdi32, "BitBlt") procBitBlt = modgdi32.NewProc("BitBlt")
) )
func GetDC(hwnd uint32) (hdc uint32) { func GetDC(hwnd syscall.Handle) (hdc syscall.Handle) {
r0, _, _ := syscall.Syscall(procGetDC, 1, uintptr(hwnd), 0, 0) r0, _, _ := syscall.Syscall(procGetDC.Addr(), 1, uintptr(hwnd), 0, 0)
hdc = uint32(r0) hdc = syscall.Handle(r0)
return hdc return hdc
} }
func CreateCompatibleDC(hwnd uint32) (hdc uint32) { func CreateCompatibleDC(hwnd syscall.Handle) (hdc syscall.Handle) {
r0, _, _ := syscall.Syscall(procCreateCompatibleDC, 1, uintptr(hwnd), 0, 0) r0, _, _ := syscall.Syscall(procCreateCompatibleDC.Addr(), 1, uintptr(hwnd), 0, 0)
hdc = uint32(r0) hdc = syscall.Handle(r0)
return hdc return hdc
} }
func GetObject(hgdiobj uint32, cbBuffer int, object uintptr) (size uint32) { func GetObject(hgdiobj syscall.Handle, cbBuffer uintptr, object uintptr) (size uint32) {
r0, _, _ := syscall.Syscall(procGetObject, 3, uintptr(hgdiobj), uintptr(cbBuffer), object) r0, _, _ := syscall.Syscall(procGetObject.Addr(), 3, uintptr(hgdiobj), uintptr(cbBuffer), object)
size = uint32(r0) size = uint32(r0)
return size return size
} }
func SelectObject(hdc uint32, hgdiobj uint32) uint32 { func SelectObject(hdc syscall.Handle, hgdiobj syscall.Handle) syscall.Handle {
r0, _, _ := syscall.Syscall(procSelectObject, 2, uintptr(hdc), uintptr(hgdiobj), 0) r0, _, _ := syscall.Syscall(procSelectObject.Addr(), 2, uintptr(hdc), uintptr(hgdiobj), 0)
return uint32(r0) return syscall.Handle(r0)
} }
func BeginPaint(hwnd uint32, ps *PAINTSTRUCT) (hdc uint32) { func BeginPaint(hwnd syscall.Handle, ps *PAINTSTRUCT) (hdc syscall.Handle){
r0, _, _ := syscall.Syscall(procBeginPaint, 2, uintptr(hwnd), uintptr(unsafe.Pointer(ps)), 0) r0, _, _ := syscall.Syscall(procBeginPaint.Addr(), 2, uintptr(hwnd), uintptr(unsafe.Pointer(ps)), 0)
hdc = uint32(r0) hdc = syscall.Handle(r0)
return hdc return
} }
func EndPaint(hwnd uint32, ps *PAINTSTRUCT) bool { func EndPaint(hwnd syscall.Handle, ps *PAINTSTRUCT) bool {
syscall.Syscall(procEndPaint, 2, uintptr(hwnd), uintptr(unsafe.Pointer(ps)), 0) syscall.Syscall(procEndPaint.Addr(), 2, uintptr(hwnd), uintptr(unsafe.Pointer(ps)), 0)
return true return true
} }
func CreateCompatibleBitmap(hdc uint32, width, height int) (hbitmap uint32) { func CreateCompatibleBitmap(hdc syscall.Handle, width, height uintptr) (hbitmap syscall.Handle) {
r0, _, _ := syscall.Syscall(procCreateCompatibleBitmap, 3, uintptr(hdc), uintptr(width), uintptr(height)) r0, _, _ := syscall.Syscall(procCreateCompatibleBitmap.Addr(), 3, uintptr(hdc), uintptr(width), uintptr(height))
return uint32(r0) return syscall.Handle(r0)
} }
func CreateDIBSection(hdc uint32, pbmi *BITMAPINFO, iUsage uint, ppvBits uintptr, hSection uint32, dwOffset uint32) (hbitmap uint32) { func CreateDIBSection(hdc syscall.Handle, pbmi *BITMAPINFO, iUsage uint, ppvBits uintptr, hSection uint32, dwOffset uint32) (hbitmap syscall.Handle) {
r0, _, _ := syscall.Syscall6(procCreateDIBSection, 6, uintptr(hdc), uintptr(unsafe.Pointer(pbmi)), uintptr(iUsage), ppvBits, uintptr(hSection), uintptr(dwOffset)) r0, _, _ := syscall.Syscall6(procCreateDIBSection.Addr(), 6, uintptr(hdc), uintptr(unsafe.Pointer(pbmi)), uintptr(iUsage), ppvBits, uintptr(hSection), uintptr(dwOffset))
return uint32(r0) return syscall.Handle(r0)
} }
func BitBlt(hdc uint32, nXDest, nYDest, nWidth, nHeight int, hdcSrc uint32, nXSrc, nYSrc int, dwRop uint32) bool { func BitBlt(hdc syscall.Handle, nXDest, nYDest, nWidth, nHeight int, hdcSrc syscall.Handle, nXSrc, nYSrc int, dwRop uint32) bool {
r0, _, _ := syscall.Syscall9(procBitBlt, 9, uintptr(hdc), uintptr(nXDest), uintptr(nYDest), uintptr(nWidth), uintptr(nHeight), uintptr(hdcSrc), uintptr(nXSrc), uintptr(nYSrc), uintptr(dwRop)) r0, _, _ := syscall.Syscall9(procBitBlt.Addr(), 9, uintptr(hdc), uintptr(nXDest), uintptr(nYDest), uintptr(nWidth), uintptr(nHeight), uintptr(hdcSrc), uintptr(nXSrc), uintptr(nYSrc), uintptr(dwRop))
return r0 != 0 return r0 != 0
} }

151
wingui/wintest/wintest.go Normal file
View file

@ -0,0 +1,151 @@
package main
import (
"fmt"
"os"
"syscall"
"unsafe"
. "code.google.com/p/draw2d/wingui"
)
// some help functions
func abortf(format string, a ...interface{}) {
fmt.Fprintf(os.Stdout, format, a...)
os.Exit(1)
}
func abortErrNo(funcname string, err error) {
errno, _ := err.(syscall.Errno)
abortf("%s failed: %d %s\n", funcname, uint32(errno), err)
}
// global vars
var (
mh syscall.Handle
bh syscall.Handle
)
// WinProc called by windows to notify us of all windows events we might be interested in.
func WndProc(hwnd syscall.Handle, msg uint32, wparam, lparam uintptr) (rc uintptr) {
_ = make([]int, 100000)
switch msg {
case WM_CREATE:
var e error
// CreateWindowEx
bh, e = CreateWindowEx(
0,
syscall.StringToUTF16Ptr("button"),
syscall.StringToUTF16Ptr("Quit"),
WS_CHILD|WS_VISIBLE|BS_DEFPUSHBUTTON,
75, 70, 140, 25,
hwnd, 1, mh, 0)
if e != nil {
abortErrNo("CreateWindowEx", e)
}
fmt.Printf("button handle is %x\n", bh)
rc = DefWindowProc(hwnd, msg, wparam, lparam)
case WM_COMMAND:
switch syscall.Handle(lparam) {
case bh:
e := PostMessage(hwnd, WM_CLOSE, 0, 0)
if e != nil {
abortErrNo("PostMessage", e)
}
default:
rc = DefWindowProc(hwnd, msg, wparam, lparam)
}
case WM_CLOSE:
DestroyWindow(hwnd)
case WM_DESTROY:
PostQuitMessage(0)
default:
rc = DefWindowProc(hwnd, msg, wparam, lparam)
}
//fmt.Printf("WndProc(0x%08x, %d, 0x%08x, 0x%08x) (%d)\n", hwnd, msg, wparam, lparam, rc)
return
}
func rungui() int {
var e error
// GetModuleHandle
mh, e = GetModuleHandle(nil)
if e != nil {
abortErrNo("GetModuleHandle", e)
}
// Get icon we're going to use.
myicon, e := LoadIcon(0, IDI_APPLICATION)
if e != nil {
abortErrNo("LoadIcon", e)
}
// Get cursor we're going to use.
mycursor, e := LoadCursor(0, IDC_ARROW)
if e != nil {
abortErrNo("LoadCursor", e)
}
// Create callback
wproc := syscall.NewCallback(WndProc)
// RegisterClassEx
wcname := syscall.StringToUTF16Ptr("myWindowClass")
var wc Wndclassex
wc.Size = uint32(unsafe.Sizeof(wc))
wc.WndProc = wproc
wc.Instance = mh
wc.Icon = myicon
wc.Cursor = mycursor
wc.Background = COLOR_BTNFACE + 1
wc.MenuName = nil
wc.ClassName = wcname
wc.IconSm = myicon
if _, e := RegisterClassEx(&wc); e != nil {
abortErrNo("RegisterClassEx", e)
}
// CreateWindowEx
wh, e := CreateWindowEx(
WS_EX_CLIENTEDGE,
wcname,
syscall.StringToUTF16Ptr("My window"),
WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, CW_USEDEFAULT, 300, 200,
0, 0, mh, 0)
if e != nil {
abortErrNo("CreateWindowEx", e)
}
fmt.Printf("main window handle is %x\n", wh)
// ShowWindow
ShowWindow(wh, SW_SHOWDEFAULT)
// UpdateWindow
if e := UpdateWindow(wh); e != nil {
abortErrNo("UpdateWindow", e)
}
// Process all windows messages until WM_QUIT.
var m Msg
for {
r, e := GetMessage(&m, 0, 0, 0)
if e != nil {
abortErrNo("GetMessage", e)
}
if r == 0 {
// WM_QUIT received -> get out
break
}
TranslateMessage(&m)
DispatchMessage(&m)
}
return int(m.Wparam)
}
func main() {
rc := rungui()
os.Exit(rc)
}

146
cmd/testWalkDraw.go → wingui/wintestgdi/wintestgdi.go
View file

@ -1,54 +1,54 @@
// Copyright 2011 The Go Authors. All rights reserved. // Copyright 2011 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style // Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file. // license that can be found in the LICENSE file.
package main package main
import ( import (
"code.google.com/p/draw2d/draw2d" "code.google.com/p/draw2d/draw2d"
"code.google.com/p/draw2d/postscript"
"code.google.com/p/draw2d/wingui" "code.google.com/p/draw2d/wingui"
"code.google.com/p/draw2d/postscript"
"fmt" "fmt"
"image" "image"
"image/color"
"io/ioutil" "io/ioutil"
"os" "image/color"
"strings" "strings"
"os"
"syscall" "syscall"
"time" "time"
"unsafe" "unsafe"
) )
// some help functions // some help functions
func abortf(format string, a ...interface{}) { func abortf(format string, a ...interface{}) {
fmt.Fprintf(os.Stdout, format, a...) fmt.Fprintf(os.Stdout, format, a...)
os.Exit(1) os.Exit(1)
} }
func abortErrNo(funcname string, err int) { func abortErrNo(funcname string, err error) {
abortf("%s failed: %d %s\n", funcname, err, syscall.Errstr(err)) abortf("%s failed: %d %s\n", funcname, err, err)
} }
// global vars // global vars
func TestDrawCubicCurve(gc draw2d.GraphicContext) { func TestDrawCubicCurve(gc draw2d.GraphicContext) {
// draw a cubic curve // draw a cubic curve
x, y := 25.6, 128.0 x, y := 25.6, 128.0
x1, y1 := 102.4, 230.4 x1, y1 := 102.4, 230.4
x2, y2 := 153.6, 25.6 x2, y2 := 153.6, 25.6
x3, y3 := 230.4, 128.0 x3, y3 := 230.4, 128.0
gc.SetFillColor(color.NRGBA{0xAA, 0xAA, 0xAA, 0xFF}) gc.SetStrokeColor(color.NRGBA{0, 0, 0, 0xFF})
gc.SetLineWidth(10) gc.SetLineWidth(10)
gc.MoveTo(x, y) gc.MoveTo(x, y)
gc.CubicCurveTo(x1, y1, x2, y2, x3, y3) gc.CubicCurveTo(x1, y1, x2, y2, x3, y3)
gc.Stroke() gc.Stroke()
gc.SetStrokeColor(color.NRGBA{0xFF, 0x33, 0x33, 0x88}) gc.SetStrokeColor(color.NRGBA{0xFF, 0, 0, 0xFF})
gc.SetLineWidth(6) gc.SetLineWidth(6)
// draw segment of curve // draw segment of curve
gc.MoveTo(x, y) gc.MoveTo(x, y)
gc.LineTo(x1, y1) gc.LineTo(x1, y1)
gc.LineTo(x2, y2) gc.LineTo(x2, y2)
@ -56,20 +56,35 @@ func TestDrawCubicCurve(gc draw2d.GraphicContext) {
gc.Stroke() gc.Stroke()
} }
func DrawTiger(gc draw2d.GraphicContext){
if postscriptContent == "" {
src, err := os.OpenFile("../../resource/postscript/tiger.ps", 0, 0)
if err != nil {
fmt.Println("can't find postscript file.")
return
}
defer src.Close()
bytes, err := ioutil.ReadAll(src)
postscriptContent = string(bytes)
}
interpreter := postscript.NewInterpreter(gc)
reader := strings.NewReader(postscriptContent)
interpreter.Execute(reader)
}
var ( var (
mh uint32 mh syscall.Handle
wndBufferHeader uint32 hdcWndBuffer syscall.Handle
wndBufferHeader syscall.Handle
wndBuffer wingui.BITMAP wndBuffer wingui.BITMAP
hdcWndBuffer uint32 ppvBits *uint8
ppvBits *color.RGBA backBuffer *image.RGBA
backBuffer *image.RGBA
postscriptContent string postscriptContent string
) )
// WinProc called by windows to notify us of all windows events we might be interested in. // WinProc called by windows to notify us of all windows events we might be interested in.
func WndProc(hwnd, msg uint32, wparam, lparam int32) uintptr { func WndProc(hwnd syscall.Handle, msg uint32, wparam, lparam uintptr) (rc uintptr) {
var rc int32 _ = make([]int, 100000)
switch msg { switch msg {
case wingui.WM_CREATE: case wingui.WM_CREATE:
hdc := wingui.GetDC(hwnd) hdc := wingui.GetDC(hwnd)
@ -82,7 +97,7 @@ func WndProc(hwnd, msg uint32, wparam, lparam int32) uintptr {
bmp_header.Size = uint32(unsafe.Sizeof(bmp_header)) bmp_header.Size = uint32(unsafe.Sizeof(bmp_header))
bmp_header.Width = 600 bmp_header.Width = 600
bmp_header.Height = 800 bmp_header.Height = 800
bmp_header.SizeImage = 0 // the api says this must be 0 for BI_RGB images bmp_header.SizeImage = 0 // the api says this must be 0 for BI_RGB images
bmp_header.Compression = wingui.BI_RGB bmp_header.Compression = wingui.BI_RGB
bmp_header.BitCount = 32 bmp_header.BitCount = 32
bmp_header.Planes = 1 bmp_header.Planes = 1
@ -90,7 +105,7 @@ func WndProc(hwnd, msg uint32, wparam, lparam int32) uintptr {
bmp_header.YPelsPerMeter = 0 bmp_header.YPelsPerMeter = 0
bmp_header.ClrUsed = 0 bmp_header.ClrUsed = 0
bmp_header.ClrImportant = 0 bmp_header.ClrImportant = 0
//bitmap info //bitmap info
var bmpinfo wingui.BITMAPINFO var bmpinfo wingui.BITMAPINFO
bmpinfo.Colors[0].Blue = 0 bmpinfo.Colors[0].Blue = 0
bmpinfo.Colors[0].Green = 0 bmpinfo.Colors[0].Green = 0
@ -102,35 +117,41 @@ func WndProc(hwnd, msg uint32, wparam, lparam int32) uintptr {
hdcWndBuffer = wingui.CreateCompatibleDC(hdc) hdcWndBuffer = wingui.CreateCompatibleDC(hdc)
wingui.SelectObject(hdcWndBuffer, wndBufferHeader) wingui.SelectObject(hdcWndBuffer, wndBufferHeader)
pixel := (*[600 * 800]color.RGBA)(unsafe.Pointer(ppvBits)) pixel := (*[600 * 800 * 4]uint8)(unsafe.Pointer(ppvBits))
pixelSlice := pixel[:] pixelSlice := pixel[:]
backBuffer = &image.RGBA{pixelSlice, 600, image.Rect(0, 0, 600, 800)} backBuffer = &image.RGBA{pixelSlice, 4*600, image.Rect(0, 0, 600, 800)}
fmt.Println("Create windows") fmt.Println("Create windows")
rc = wingui.DefWindowProc(hwnd, msg, wparam, lparam) rc = wingui.DefWindowProc(hwnd, msg, wparam, lparam)
case wingui.WM_COMMAND: case wingui.WM_COMMAND:
switch uint32(lparam) { switch syscall.Handle(lparam) {
default: default:
rc = wingui.DefWindowProc(hwnd, msg, wparam, lparam) rc = wingui.DefWindowProc(hwnd, msg, wparam, lparam)
} }
case wingui.WM_PAINT: case wingui.WM_PAINT:
var ps wingui.PAINTSTRUCT var ps wingui.PAINTSTRUCT
lastTime := time.Now()
hdc := wingui.BeginPaint(hwnd, &ps) hdc := wingui.BeginPaint(hwnd, &ps)
t := time.Now()
gc := draw2d.NewGraphicContext(backBuffer) gc := draw2d.NewGraphicContext(backBuffer)
gc.SetFillColor(color.RGBA{0xFF, 0xFF, 0xFF, 0xFF}) /*gc.SetFillColor(color.RGBA{0xFF, 0xFF, 0xFF, 0xFF})
// gc.Clear() gc.Clear()*/
for i := 0; i < len(backBuffer.Pix); i+=1 {
backBuffer.Pix[i] = 0xff
}
gc.Save() gc.Save()
//gc.Translate(0, -380) //gc.Translate(0, -380)
interpreter := postscript.NewInterpreter(gc) DrawTiger(gc)
reader := strings.NewReader(postscriptContent)
interpreter.Execute(reader)
dt := time.Now().Sub(lastTime)
gc.Restore() gc.Restore()
// back buf in // back buf in
var tmp uint8
for i := 0; i < len(backBuffer.Pix); i+=4 {
tmp = backBuffer.Pix[i]
backBuffer.Pix[i] = backBuffer.Pix[i+2]
backBuffer.Pix[i+2] = tmp
}
wingui.BitBlt(hdc, 0, 0, int(wndBuffer.Width), int(wndBuffer.Height), hdcWndBuffer, 0, 0, wingui.SRCCOPY) wingui.BitBlt(hdc, 0, 0, int(wndBuffer.Width), int(wndBuffer.Height), hdcWndBuffer, 0, 0, wingui.SRCCOPY)
wingui.EndPaint(hwnd, &ps) wingui.EndPaint(hwnd, &ps)
rc = wingui.DefWindowProc(hwnd, msg, wparam, lparam) rc = wingui.DefWindowProc(hwnd, msg, wparam, lparam)
dt := time.Now().Sub(t)
fmt.Printf("Redraw in : %f ms\n", float64(dt)*1e-6) fmt.Printf("Redraw in : %f ms\n", float64(dt)*1e-6)
case wingui.WM_CLOSE: case wingui.WM_CLOSE:
wingui.DestroyWindow(hwnd) wingui.DestroyWindow(hwnd)
@ -139,51 +160,50 @@ func WndProc(hwnd, msg uint32, wparam, lparam int32) uintptr {
default: default:
rc = wingui.DefWindowProc(hwnd, msg, wparam, lparam) rc = wingui.DefWindowProc(hwnd, msg, wparam, lparam)
} }
return uintptr(rc) return
} }
func rungui() int { func rungui() int {
var e int var e error
// GetModuleHandle // GetModuleHandle
mh, e = wingui.GetModuleHandle(nil) mh, e = wingui.GetModuleHandle(nil)
if e != 0 { if e != nil {
abortErrNo("GetModuleHandle", e) abortErrNo("GetModuleHandle", e)
} }
// Get icon we're going to use. // Get icon we're going to use.
myicon, e := wingui.LoadIcon(0, wingui.IDI_APPLICATION) myicon, e := wingui.LoadIcon(0, wingui.IDI_APPLICATION)
if e != 0 { if e != nil {
abortErrNo("LoadIcon", e) abortErrNo("LoadIcon", e)
} }
// Get cursor we're going to use. // Get cursor we're going to use.
mycursor, e := wingui.LoadCursor(0, wingui.IDC_ARROW) mycursor, e := wingui.LoadCursor(0, wingui.IDC_ARROW)
if e != 0 { if e != nil {
abortErrNo("LoadCursor", e) abortErrNo("LoadCursor", e)
} }
// Create callback // Create callback
wproc := syscall.NewCallback(WndProc) wproc := syscall.NewCallback(WndProc)
// RegisterClassEx // RegisterClassEx
wcname := syscall.StringToUTF16Ptr("Test Draw2d") wcname := syscall.StringToUTF16Ptr("myWindowClass")
var wc wingui.Wndclassex var wc wingui.Wndclassex
wc.Size = uint32(unsafe.Sizeof(wc)) wc.Size = uint32(unsafe.Sizeof(wc))
wc.WndProc = wproc wc.WndProc = wproc
//wc.Style = wingui.CS_HREDRAW | wingui.CS_VREDRAW
wc.Instance = mh wc.Instance = mh
wc.Icon = myicon wc.Icon = myicon
wc.Cursor = mycursor wc.Cursor = mycursor
wc.Background = 0 wc.Background = wingui.COLOR_BTNFACE + 1
wc.MenuName = nil wc.MenuName = nil
wc.ClassName = wcname wc.ClassName = wcname
wc.IconSm = myicon wc.IconSm = myicon
if _, e := wingui.RegisterClassEx(&wc); e != 0 { if _, e := wingui.RegisterClassEx(&wc); e != nil {
abortErrNo("RegisterClassEx", e) abortErrNo("RegisterClassEx", e)
} }
// CreateWindowEx // CreateWindowEx
wh, e := wingui.CreateWindowEx( wh, e := wingui.CreateWindowEx(
wingui.WS_EX_CLIENTEDGE, wingui.WS_EX_CLIENTEDGE,
wcname, wcname,
@ -191,28 +211,28 @@ func rungui() int {
wingui.WS_OVERLAPPEDWINDOW, wingui.WS_OVERLAPPEDWINDOW,
wingui.CW_USEDEFAULT, wingui.CW_USEDEFAULT, 600, 800, wingui.CW_USEDEFAULT, wingui.CW_USEDEFAULT, 600, 800,
0, 0, mh, 0) 0, 0, mh, 0)
if e != 0 { if e != nil {
abortErrNo("CreateWindowEx", e) abortErrNo("CreateWindowEx", e)
} }
fmt.Printf("main window handle is %x\n", wh) fmt.Printf("main window handle is %x\n", wh)
// ShowWindow // ShowWindow
wingui.ShowWindow(wh, wingui.SW_SHOWDEFAULT) wingui.ShowWindow(wh, wingui.SW_SHOWDEFAULT)
// UpdateWindow // UpdateWindow
if e := wingui.UpdateWindow(wh); e != 0 { if e := wingui.UpdateWindow(wh); e != nil {
abortErrNo("UpdateWindow", e) abortErrNo("UpdateWindow", e)
} }
// Process all windows messages until WM_QUIT. // Process all windows messages until WM_QUIT.
var m wingui.Msg var m wingui.Msg
for { for {
r, e := wingui.GetMessage(&m, 0, 0, 0) r, e := wingui.GetMessage(&m, 0, 0, 0)
if e != 0 { if e != nil {
abortErrNo("GetMessage", e) abortErrNo("GetMessage", e)
} }
if r == 0 { if r == 0 {
// WM_QUIT received -> get out // WM_QUIT received -> get out
break break
} }
wingui.TranslateMessage(&m) wingui.TranslateMessage(&m)
@ -222,14 +242,6 @@ func rungui() int {
} }
func main() { func main() {
src, err := os.OpenFile("../resource/postscript/tiger.ps", 0, 0)
if err != nil {
fmt.Println("can't find postscript file.")
return
}
defer src.Close()
bytes, err := ioutil.ReadAll(src)
postscriptContent = string(bytes)
rc := rungui() rc := rungui()
os.Exit(rc) os.Exit(rc)
} }

316
wingui/zwinapi.go
View file

@ -1,208 +1,192 @@
// +build windows
// mksyscall_windows.pl winapi.go
// MACHINE GENERATED BY THE COMMAND ABOVE; DO NOT EDIT
package wingui package wingui
import "unsafe" import "unsafe"
import "syscall" import "syscall"
var ( var (
modkernel32 = loadDll("kernel32.dll") modkernel32 = syscall.NewLazyDLL("kernel32.dll")
moduser32 = loadDll("user32.dll") moduser32 = syscall.NewLazyDLL("user32.dll")
procGetModuleHandleW = getSysProcAddr(modkernel32, "GetModuleHandleW") procGetModuleHandleW = modkernel32.NewProc("GetModuleHandleW")
procRegisterClassExW = getSysProcAddr(moduser32, "RegisterClassExW") procRegisterClassExW = moduser32.NewProc("RegisterClassExW")
procCreateWindowExW = getSysProcAddr(moduser32, "CreateWindowExW") procCreateWindowExW = moduser32.NewProc("CreateWindowExW")
procDefWindowProcW = getSysProcAddr(moduser32, "DefWindowProcW") procDefWindowProcW = moduser32.NewProc("DefWindowProcW")
procDestroyWindow = getSysProcAddr(moduser32, "DestroyWindow") procDestroyWindow = moduser32.NewProc("DestroyWindow")
procPostQuitMessage = getSysProcAddr(moduser32, "PostQuitMessage") procPostQuitMessage = moduser32.NewProc("PostQuitMessage")
procShowWindow = getSysProcAddr(moduser32, "ShowWindow") procShowWindow = moduser32.NewProc("ShowWindow")
procUpdateWindow = getSysProcAddr(moduser32, "UpdateWindow") procUpdateWindow = moduser32.NewProc("UpdateWindow")
procGetMessageW = getSysProcAddr(moduser32, "GetMessageW") procGetMessageW = moduser32.NewProc("GetMessageW")
procTranslateMessage = getSysProcAddr(moduser32, "TranslateMessage") procTranslateMessage = moduser32.NewProc("TranslateMessage")
procDispatchMessageW = getSysProcAddr(moduser32, "DispatchMessageW") procDispatchMessageW = moduser32.NewProc("DispatchMessageW")
procLoadIconW = getSysProcAddr(moduser32, "LoadIconW") procLoadIconW = moduser32.NewProc("LoadIconW")
procLoadCursorW = getSysProcAddr(moduser32, "LoadCursorW") procLoadCursorW = moduser32.NewProc("LoadCursorW")
procSetCursor = getSysProcAddr(moduser32, "SetCursor") procSetCursor = moduser32.NewProc("SetCursor")
procSendMessageW = getSysProcAddr(moduser32, "SendMessageW") procSendMessageW = moduser32.NewProc("SendMessageW")
procPostMessageW = getSysProcAddr(moduser32, "PostMessageW") procPostMessageW = moduser32.NewProc("PostMessageW")
) )
func GetModuleHandle(modname *uint16) (handle uint32, errno int) { func GetModuleHandle(modname *uint16) (handle syscall.Handle, err error) {
r0, _, e1 := syscall.Syscall(procGetModuleHandleW, 1, uintptr(unsafe.Pointer(modname)), 0, 0) r0, _, e1 := syscall.Syscall(procGetModuleHandleW.Addr(), 1, uintptr(unsafe.Pointer(modname)), 0, 0)
handle = uint32(r0) handle = syscall.Handle(r0)
if handle == 0 { if handle == 0 {
if e1 != 0 { if e1 != 0 {
errno = int(e1) err = error(e1)
} else { } else {
errno = syscall.EINVAL err = syscall.EINVAL
} }
} else { }
errno = 0 return
}
return
} }
func RegisterClassEx(wndclass *Wndclassex) (atom uint16, errno int) { func RegisterClassEx(wndclass *Wndclassex) (atom uint16, err error) {
r0, _, e1 := syscall.Syscall(procRegisterClassExW, 1, uintptr(unsafe.Pointer(wndclass)), 0, 0) r0, _, e1 := syscall.Syscall(procRegisterClassExW.Addr(), 1, uintptr(unsafe.Pointer(wndclass)), 0, 0)
atom = uint16(r0) atom = uint16(r0)
if atom == 0 { if atom == 0 {
if e1 != 0 { if e1 != 0 {
errno = int(e1) err = error(e1)
} else { } else {
errno = syscall.EINVAL err = syscall.EINVAL
} }
} else { }
errno = 0 return
}
return
} }
func CreateWindowEx(exstyle uint32, classname *uint16, windowname *uint16, style uint32, x int32, y int32, width int32, height int32, wndparent uint32, menu uint32, instance uint32, param uintptr) (hwnd uint32, errno int) { func CreateWindowEx(exstyle uint32, classname *uint16, windowname *uint16, style uint32, x int32, y int32, width int32, height int32, wndparent syscall.Handle, menu syscall.Handle, instance syscall.Handle, param uintptr) (hwnd syscall.Handle, err error) {
r0, _, e1 := syscall.Syscall12(procCreateWindowExW, 12, uintptr(exstyle), uintptr(unsafe.Pointer(classname)), uintptr(unsafe.Pointer(windowname)), uintptr(style), uintptr(x), uintptr(y), uintptr(width), uintptr(height), uintptr(wndparent), uintptr(menu), uintptr(instance), uintptr(param)) r0, _, e1 := syscall.Syscall12(procCreateWindowExW.Addr(), 12, uintptr(exstyle), uintptr(unsafe.Pointer(classname)), uintptr(unsafe.Pointer(windowname)), uintptr(style), uintptr(x), uintptr(y), uintptr(width), uintptr(height), uintptr(wndparent), uintptr(menu), uintptr(instance), uintptr(param))
hwnd = uint32(r0) hwnd = syscall.Handle(r0)
if hwnd == 0 { if hwnd == 0 {
if e1 != 0 { if e1 != 0 {
errno = int(e1) err = error(e1)
} else { } else {
errno = syscall.EINVAL err = syscall.EINVAL
} }
} else { }
errno = 0 return
}
return
} }
func DefWindowProc(hwnd uint32, msg uint32, wparam int32, lparam int32) (lresult int32) { func DefWindowProc(hwnd syscall.Handle, msg uint32, wparam uintptr, lparam uintptr) (lresult uintptr) {
r0, _, _ := syscall.Syscall6(procDefWindowProcW, 4, uintptr(hwnd), uintptr(msg), uintptr(wparam), uintptr(lparam), 0, 0) r0, _, _ := syscall.Syscall6(procDefWindowProcW.Addr(), 4, uintptr(hwnd), uintptr(msg), uintptr(wparam), uintptr(lparam), 0, 0)
lresult = int32(r0) lresult = uintptr(r0)
return return
} }
func DestroyWindow(hwnd uint32) (errno int) { func DestroyWindow(hwnd syscall.Handle) (err error) {
r1, _, e1 := syscall.Syscall(procDestroyWindow, 1, uintptr(hwnd), 0, 0) r1, _, e1 := syscall.Syscall(procDestroyWindow.Addr(), 1, uintptr(hwnd), 0, 0)
if int(r1) == 0 { if int(r1) == 0 {
if e1 != 0 { if e1 != 0 {
errno = int(e1) err = error(e1)
} else { } else {
errno = syscall.EINVAL err = syscall.EINVAL
} }
} else { }
errno = 0 return
}
return
} }
func PostQuitMessage(exitcode int32) { func PostQuitMessage(exitcode int32) {
syscall.Syscall(procPostQuitMessage, 1, uintptr(exitcode), 0, 0) syscall.Syscall(procPostQuitMessage.Addr(), 1, uintptr(exitcode), 0, 0)
return return
} }
func ShowWindow(hwnd uint32, cmdshow int32) (wasvisible bool) { func ShowWindow(hwnd syscall.Handle, cmdshow int32) (wasvisible bool) {
r0, _, _ := syscall.Syscall(procShowWindow, 2, uintptr(hwnd), uintptr(cmdshow), 0) r0, _, _ := syscall.Syscall(procShowWindow.Addr(), 2, uintptr(hwnd), uintptr(cmdshow), 0)
wasvisible = bool(r0 != 0) wasvisible = bool(r0 != 0)
return return
} }
func UpdateWindow(hwnd uint32) (errno int) { func UpdateWindow(hwnd syscall.Handle) (err error) {
r1, _, e1 := syscall.Syscall(procUpdateWindow, 1, uintptr(hwnd), 0, 0) r1, _, e1 := syscall.Syscall(procUpdateWindow.Addr(), 1, uintptr(hwnd), 0, 0)
if int(r1) == 0 { if int(r1) == 0 {
if e1 != 0 { if e1 != 0 {
errno = int(e1) err = error(e1)
} else { } else {
errno = syscall.EINVAL err = syscall.EINVAL
} }
} else { }
errno = 0 return
}
return
} }
func GetMessage(msg *Msg, hwnd uint32, MsgFilterMin uint32, MsgFilterMax uint32) (ret int32, errno int) { func GetMessage(msg *Msg, hwnd syscall.Handle, MsgFilterMin uint32, MsgFilterMax uint32) (ret int32, err error) {
r0, _, e1 := syscall.Syscall6(procGetMessageW, 4, uintptr(unsafe.Pointer(msg)), uintptr(hwnd), uintptr(MsgFilterMin), uintptr(MsgFilterMax), 0, 0) r0, _, e1 := syscall.Syscall6(procGetMessageW.Addr(), 4, uintptr(unsafe.Pointer(msg)), uintptr(hwnd), uintptr(MsgFilterMin), uintptr(MsgFilterMax), 0, 0)
ret = int32(r0) ret = int32(r0)
if ret == -1 { if ret == -1 {
if e1 != 0 { if e1 != 0 {
errno = int(e1) err = error(e1)
} else { } else {
errno = syscall.EINVAL err = syscall.EINVAL
} }
} else { }
errno = 0 return
}
return
} }
func TranslateMessage(msg *Msg) (done bool) { func TranslateMessage(msg *Msg) (done bool) {
r0, _, _ := syscall.Syscall(procTranslateMessage, 1, uintptr(unsafe.Pointer(msg)), 0, 0) r0, _, _ := syscall.Syscall(procTranslateMessage.Addr(), 1, uintptr(unsafe.Pointer(msg)), 0, 0)
done = bool(r0 != 0) done = bool(r0 != 0)
return return
} }
func DispatchMessage(msg *Msg) (ret int32) { func DispatchMessage(msg *Msg) (ret int32) {
r0, _, _ := syscall.Syscall(procDispatchMessageW, 1, uintptr(unsafe.Pointer(msg)), 0, 0) r0, _, _ := syscall.Syscall(procDispatchMessageW.Addr(), 1, uintptr(unsafe.Pointer(msg)), 0, 0)
ret = int32(r0) ret = int32(r0)
return return
} }
func LoadIcon(instance uint32, iconname *uint16) (icon uint32, errno int) { func LoadIcon(instance syscall.Handle, iconname *uint16) (icon syscall.Handle, err error) {
r0, _, e1 := syscall.Syscall(procLoadIconW, 2, uintptr(instance), uintptr(unsafe.Pointer(iconname)), 0) r0, _, e1 := syscall.Syscall(procLoadIconW.Addr(), 2, uintptr(instance), uintptr(unsafe.Pointer(iconname)), 0)
icon = uint32(r0) icon = syscall.Handle(r0)
if icon == 0 { if icon == 0 {
if e1 != 0 { if e1 != 0 {
errno = int(e1) err = error(e1)
} else { } else {
errno = syscall.EINVAL err = syscall.EINVAL
} }
} else { }
errno = 0 return
}
return
} }
func LoadCursor(instance uint32, cursorname *uint16) (cursor uint32, errno int) { func LoadCursor(instance syscall.Handle, cursorname *uint16) (cursor syscall.Handle, err error) {
r0, _, e1 := syscall.Syscall(procLoadCursorW, 2, uintptr(instance), uintptr(unsafe.Pointer(cursorname)), 0) r0, _, e1 := syscall.Syscall(procLoadCursorW.Addr(), 2, uintptr(instance), uintptr(unsafe.Pointer(cursorname)), 0)
cursor = uint32(r0) cursor = syscall.Handle(r0)
if cursor == 0 { if cursor == 0 {
if e1 != 0 { if e1 != 0 {
errno = int(e1) err = error(e1)
} else { } else {
errno = syscall.EINVAL err = syscall.EINVAL
} }
} else { }
errno = 0 return
}
return
} }
func SetCursor(cursor uint32) (precursor uint32, errno int) { func SetCursor(cursor syscall.Handle) (precursor syscall.Handle, err error) {
r0, _, e1 := syscall.Syscall(procSetCursor, 1, uintptr(cursor), 0, 0) r0, _, e1 := syscall.Syscall(procSetCursor.Addr(), 1, uintptr(cursor), 0, 0)
precursor = uint32(r0) precursor = syscall.Handle(r0)
if precursor == 0 { if precursor == 0 {
if e1 != 0 { if e1 != 0 {
errno = int(e1) err = error(e1)
} else { } else {
errno = syscall.EINVAL err = syscall.EINVAL
} }
} else { }
errno = 0 return
}
return
} }
func SendMessage(hwnd uint32, msg uint32, wparam int32, lparam int32) (lresult int32) { func SendMessage(hwnd syscall.Handle, msg uint32, wparam uintptr, lparam uintptr) (lresult uintptr) {
r0, _, _ := syscall.Syscall6(procSendMessageW, 4, uintptr(hwnd), uintptr(msg), uintptr(wparam), uintptr(lparam), 0, 0) r0, _, _ := syscall.Syscall6(procSendMessageW.Addr(), 4, uintptr(hwnd), uintptr(msg), uintptr(wparam), uintptr(lparam), 0, 0)
lresult = int32(r0) lresult = uintptr(r0)
return return
} }
func PostMessage(hwnd uint32, msg uint32, wparam int32, lparam int32) (errno int) { func PostMessage(hwnd syscall.Handle, msg uint32, wparam uintptr, lparam uintptr) (err error) {
r1, _, e1 := syscall.Syscall6(procPostMessageW, 4, uintptr(hwnd), uintptr(msg), uintptr(wparam), uintptr(lparam), 0, 0) r1, _, e1 := syscall.Syscall6(procPostMessageW.Addr(), 4, uintptr(hwnd), uintptr(msg), uintptr(wparam), uintptr(lparam), 0, 0)
if int(r1) == 0 { if int(r1) == 0 {
if e1 != 0 { if e1 != 0 {
errno = int(e1) err = error(e1)
} else { } else {
errno = syscall.EINVAL err = syscall.EINVAL
} }
} else { }
errno = 0 return
} }
return
}