func DetachNotifyHandler(hwnd uint32) { key := uintptr(hwnd) if _, exists := notifyHandlers[key]; exists { C.HTMLayoutSetCallback(C.HWND(C.HANDLE(key)), nil, nil) delete(notifyHandlers, key) } }
func RootElement(hwnd uint32) *Element { var handle HELEMENT = BAD_HELEMENT if ret := C.HTMLayoutGetRootElement(C.HWND(C.HANDLE(uintptr(hwnd))), (*C.HELEMENT)(&handle)); ret != HLDOM_OK { domPanic(ret, "Failed to get root element") } return NewElementFromHandle(handle) }
func toggleFullscreen(window C.HWND) { style := C.GetWindowLong(window, C.GWL_STYLE) if style&C.WS_OVERLAPPEDWINDOW != 0 { // go into full-screen monitorInfo := C.MONITORINFO{cbSize: C.sizeof_MONITORINFO} previousPlacement.length = C.sizeof_WINDOWPLACEMENT monitor := C.MonitorFromWindow(window, C.MONITOR_DEFAULTTOPRIMARY) if C.GetWindowPlacement(window, &previousPlacement) != 0 && C.GetMonitorInfo(monitor, &monitorInfo) != 0 { C.SetWindowLong(window, C.GWL_STYLE, style & ^C.WS_OVERLAPPEDWINDOW) C.SetWindowPos(window, C.HWND(unsafe.Pointer(uintptr(0))), C.int(monitorInfo.rcMonitor.left), C.int(monitorInfo.rcMonitor.top), C.int(monitorInfo.rcMonitor.right-monitorInfo.rcMonitor.left), C.int(monitorInfo.rcMonitor.bottom-monitorInfo.rcMonitor.top), C.SWP_NOOWNERZORDER|C.SWP_FRAMECHANGED, ) } } else { // go into windowed mode C.SetWindowLong(window, C.GWL_STYLE, style|C.WS_OVERLAPPEDWINDOW) C.SetWindowPlacement(window, &previousPlacement) C.SetWindowPos(window, nil, 0, 0, 0, 0, C.SWP_NOMOVE|C.SWP_NOSIZE|C.SWP_NOZORDER| C.SWP_NOOWNERZORDER|C.SWP_FRAMECHANGED, ) } }
// Load html contents into window func LoadHtml(hwnd uint32, data []byte, baseUrl string) error { if len(data) > 0 { if ok := C.HTMLayoutLoadHtmlEx(C.HWND(C.HANDLE(uintptr(hwnd))), (*C.BYTE)(&data[0]), C.UINT(len(data)), (*C.WCHAR)(stringToUtf16Ptr(baseUrl))); ok == 0 { return errors.New("HTMLayoutLoadHtmlEx failed") } } return nil }
func FocusedElement(hwnd uint32) *Element { var handle HELEMENT = BAD_HELEMENT if ret := C.HTMLayoutGetFocusElement(C.HWND(C.HANDLE(uintptr(hwnd))), (*C.HELEMENT)(&handle)); ret != HLDOM_OK { domPanic(ret, "Failed to get focus element") } if handle != BAD_HELEMENT { return NewElementFromHandle(handle) } return nil }
func DetachWindowEventHandler(hwnd uint32) { key := uintptr(hwnd) if handler, exists := windowEventHandlers[hwnd]; exists { tag := uintptr(unsafe.Pointer(handler)) if ret := C.HTMLayoutWindowDetachEventHandler(C.HWND(C.HANDLE(key)), (*[0]byte)(unsafe.Pointer(goElementProc)), C.LPVOID(tag)); ret != HLDOM_OK { domPanic(ret, "Failed to detach event handler from window") } delete(windowEventHandlers, hwnd) } }
func AttachWindowEventHandler(hwnd uint32, handler *EventHandler) { key := uintptr(hwnd) tag := uintptr(unsafe.Pointer(handler)) if _, exists := windowEventHandlers[hwnd]; exists { if ret := C.HTMLayoutWindowDetachEventHandler(C.HWND(C.HANDLE(key)), (*[0]byte)(unsafe.Pointer(goElementProc)), C.LPVOID(tag)); ret != HLDOM_OK { domPanic(ret, "Failed to detach event handler from window before adding the new one") } } // Overwrite if it exists windowEventHandlers[hwnd] = handler // Don't let the caller disable ATTACH/DETACH events, otherwise we // won't know when to throw out our event handler object subscription := handler.Subscription() subscription &= ^uint32(DISABLE_INITIALIZATION & 0xffffffff) if ret := C.HTMLayoutWindowAttachEventHandler(C.HWND(C.HANDLE(key)), (*[0]byte)(unsafe.Pointer(goElementProc)), C.LPVOID(tag), C.UINT(subscription)); ret != HLDOM_OK { domPanic(ret, "Failed to attach event handler to window") } }
func (obj DirectInput) RunControlPanel( ownerWindow unsafe.Pointer, flags uint32, ) ( err error, ) { err = toError(C.IDirectInput8RunControlPanel( obj.handle, C.HWND(ownerWindow), C.DWORD(flags), )) return }
func (obj Device) SetCooperativeLevel( windowHandle unsafe.Pointer, flags uint32, ) ( err error, ) { err = toError(C.IDirectInputDevice8SetCooperativeLevel( obj.handle, C.HWND(windowHandle), C.DWORD(flags), )) return }
func (ic *contextInternal) initializeFromOwner(settings ContextSettings, owner *windowInternal, bitsPerPixel uint) ThreadError { ic.deactivateSignal = make(chan bool) ic.settings = settings // Get the owner window and its device context ic.window = C.HWND(owner.window.Handle) ic.ownsWindow = false // get the device context ic.hdc = C.GetDC(ic.window) if ic.hdc == nil { return NewThreadError(errors.New("no device context"), true) } ic.context = createContext(&sharedContext.internal.procs, sharedContext.internal.context, ic.hdc, bitsPerPixel, &ic.settings) if ic.context == nil { return NewThreadError(fmt.Errorf("could not create context (%d)", C.GetLastError()), true) } // signal because we start out deactivated ic.signalDeactivation() return nil }
func AttachNotifyHandler(hwnd uint32, handler *NotifyHandler) { key := uintptr(hwnd) // Overwrite if it exists notifyHandlers[key] = handler C.HTMLayoutSetCallback(C.HWND(C.HANDLE(key)), (*[0]byte)(unsafe.Pointer(goNotifyProc)), C.LPVOID(key)) }
// Load resource (file or url) into window func LoadResource(hwnd uint32, uri string) error { if ok := C.HTMLayoutLoadFile(C.HWND(C.HANDLE(uintptr(hwnd))), (*C.WCHAR)(stringToUtf16Ptr(uri))); ok == 0 { return errors.New("HTMLayoutLoadFile failed") } return nil }
// Main htmlayout wndproc func ProcNoDefault(hwnd, msg uint32, wparam, lparam uintptr) (uintptr, bool) { var handled C.BOOL = 0 var result C.LRESULT = C.HTMLayoutProcND(C.HWND(C.HANDLE(uintptr(hwnd))), C.UINT(msg), C.WPARAM(wparam), C.LPARAM(lparam), &handled) return uintptr(result), handled != 0 }
func (s *Window) SetTitle(title string) { // message handling hwnd := C.HWND(unsafe.Pointer(s.GetHwnd())) C.SetWindowTextW(hwnd, (*C.WCHAR)(unsafe.Pointer(sciter.StringToWcharPtr(title)))) }
// #include "helper_windows.h" // // void * __HWND_BOTTOM = HWND_BOTTOM; // void * __HWND_NOTOPMOST = HWND_NOTOPMOST; // void * __HWND_TOP = HWND_TOP; // void * __HWND_TOPMOST = HWND_TOPMOST; import "C" import ( "errors" "fmt" "unicode/utf16" ) var ( HWND_BOTTOM = C.HWND(C.__HWND_BOTTOM) HWND_NOTOPMOST = C.HWND(C.__HWND_NOTOPMOST) HWND_TOP = C.HWND(C.__HWND_TOP) HWND_TOPMOST = C.HWND(C.__HWND_TOPMOST) ) func utf16Convert(s string) (ptr C.LPCWSTR, length int) { encoded := utf16.Encode([]rune(s + "\x00")) return C.LPCWSTR((*C.WCHAR)(&encoded[0])), len(encoded) } func utf16ConvertFrom(s []C.WCHAR) string { ret := make([]uint16, len(s)) for i, v := range s { ret[i] = uint16(v) }
// SetWin32Window sets the Win32 window to use for context creation. // Call before Init. func SetWin32Window(wnd uintptr) { C.bgfx_win_set_hwnd(C.HWND(unsafe.Pointer(wnd))) }
// Call this from your NotifyHandler.HandleLoadData method if you want htmlayout to // process the data right away so you don't have to provide a buffer in the NmhlLoadData structure. func DataReady(hwnd uint32, uri *uint16, data []byte) bool { return C.HTMLayoutDataReady(C.HWND(C.HANDLE(uintptr(hwnd))), (*C.WCHAR)(uri), (*C.BYTE)(&data[0]), C.DWORD(len(data))) != 0 }
func main() { // TODO enable VSync in D3D windowHandle, err := windows.OpenWindow(windowProc, windowW, windowH) check(err) window := C.HWND(windowHandle) C.SetWindowText( window, (*C.WCHAR)(syscall.StringToUTF16Ptr("Gophette's Adventure")), ) check(mixer.Init()) defer mixer.Close() C.ShowCursor(0) defer C.ShowCursor(1) check(d3d9.Init()) defer d3d9.Close() d3d, err := d3d9.Create(d3d9.SDK_VERSION) check(err) defer d3d.Release() var maxScreenW, maxScreenH uint for i := uint(0); i < d3d.GetAdapterCount(); i++ { mode, err := d3d.GetAdapterDisplayMode(i) if err == nil { if mode.Width > maxScreenW { maxScreenW = mode.Width } if mode.Height > maxScreenH { maxScreenH = mode.Height } } } if maxScreenW == 0 || maxScreenH == 0 { panic("no monitor detected") } device, _, err := d3d.CreateDevice( d3d9.ADAPTER_DEFAULT, d3d9.DEVTYPE_HAL, windowHandle, d3d9.CREATE_HARDWARE_VERTEXPROCESSING, d3d9.PRESENT_PARAMETERS{ BackBufferWidth: maxScreenW, BackBufferHeight: maxScreenH, BackBufferFormat: d3d9.FMT_A8R8G8B8, BackBufferCount: 1, Windowed: true, SwapEffect: d3d9.SWAPEFFECT_DISCARD, HDeviceWindow: windowHandle, }, ) check(err) defer device.Release() check(device.SetRenderState(d3d9.RS_CULLMODE, uint32(d3d9.CULL_CW))) check(device.SetRenderState(d3d9.RS_SRCBLEND, d3d9.BLEND_SRCALPHA)) check(device.SetRenderState(d3d9.RS_DESTBLEND, d3d9.BLEND_INVSRCALPHA)) check(device.SetRenderState(d3d9.RS_ALPHABLENDENABLE, 1)) camera = newWindowCamera(windowW, windowH) graphics := newWindowsGraphics(device, camera) defer graphics.close() assetLoader := newWindowsAssetLoader(device, graphics, camera) defer assetLoader.close() // charIndex selects which character is being controlled by the user, for // the final game this must be 0 but for creating the "AI" for Barney, set // this to 1 and delete the recorded inputs so they are not applied // additionally to the user controls const recordingAI = false // NOTE switch for development mode if !recordingAI { charIndex = 0 } else { charIndex = 1 recordedInputs = recordedInputs[:0] recordingInput = true } game = NewGame( assetLoader, graphics, camera, charIndex, ) music := assetLoader.LoadSound("music_wav") go func() { for { music.PlayOnce() time.Sleep(music.Length() + 5*time.Second) } }() toggleFullscreen(window) frameTime := time.Second / 65 lastUpdate := time.Now().Add(-frameTime) var msg C.MSG C.PeekMessage(&msg, nil, 0, 0, C.PM_NOREMOVE) for msg.message != C.WM_QUIT { if C.PeekMessage(&msg, nil, 0, 0, C.PM_REMOVE) != 0 { C.TranslateMessage(&msg) C.DispatchMessage(&msg) } else { now := time.Now() dt := now.Sub(lastUpdate) if dt > frameTime { game.Update() lastUpdate = now } check(device.SetViewport( d3d9.VIEWPORT{0, 0, uint32(windowW), uint32(windowH), 0, 1}, )) check(device.Clear( nil, d3d9.CLEAR_TARGET, d3d9.ColorRGB(0, 95, 83), 1, 0, )) game.Render() graphics.flush() check(device.Present( &d3d9.RECT{0, 0, int32(windowW), int32(windowH)}, nil, nil, nil, )) } } }