1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
|
// 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
import (
"fmt"
"image"
"sync"
"syscall"
"unsafe"
"golang.org/x/exp/shiny/driver/internal/win32"
"golang.org/x/exp/shiny/screen"
)
var theScreen = &screenImpl{
windows: make(map[syscall.Handle]*windowImpl),
}
type screenImpl struct {
mu sync.Mutex
windows map[syscall.Handle]*windowImpl
}
func (*screenImpl) NewBuffer(size image.Point) (screen.Buffer, error) {
// Buffer length must fit in BITMAPINFO.Header.SizeImage (uint32), as
// well as in Go slice length (int). It's easiest to be consistent
// between 32-bit and 64-bit, so we just use int32.
const (
maxInt32 = 0x7fffffff
maxBufLen = maxInt32
)
if size.X < 0 || size.X > maxInt32 || size.Y < 0 || size.Y > maxInt32 || int64(size.X)*int64(size.Y)*4 > maxBufLen {
return nil, fmt.Errorf("windriver: invalid buffer size %v", size)
}
hbitmap, bitvalues, err := mkbitmap(size)
if err != nil {
return nil, err
}
bufLen := 4 * size.X * size.Y
array := (*[maxBufLen]byte)(unsafe.Pointer(bitvalues))
buf := (*array)[:bufLen:bufLen]
return &bufferImpl{
hbitmap: hbitmap,
buf: buf,
rgba: image.RGBA{
Pix: buf,
Stride: 4 * size.X,
Rect: image.Rectangle{Max: size},
},
size: size,
}, nil
}
func (*screenImpl) NewTexture(size image.Point) (screen.Texture, error) {
return newTexture(size)
}
func (s *screenImpl) NewWindow(opts *screen.NewWindowOptions) (screen.Window, error) {
w := &windowImpl{}
var err error
w.hwnd, err = win32.NewWindow(opts)
if err != nil {
return nil, err
}
s.mu.Lock()
s.windows[w.hwnd] = w
s.mu.Unlock()
err = win32.ResizeClientRect(w.hwnd, opts)
if err != nil {
return nil, err
}
win32.Show(w.hwnd)
return w, nil
}
|
