summaryrefslogtreecommitdiff
path: root/src/pkg/exp
diff options
context:
space:
mode:
Diffstat (limited to 'src/pkg/exp')
-rw-r--r--src/pkg/exp/datafmt/datafmt.go2
-rw-r--r--src/pkg/exp/draw/draw.go363
-rw-r--r--src/pkg/exp/draw/draw_test.go228
-rw-r--r--src/pkg/exp/eval/expr.go2
-rw-r--r--src/pkg/exp/eval/gen.go4
-rw-r--r--src/pkg/exp/eval/stmt.go6
-rw-r--r--src/pkg/exp/eval/typec.go2
-rw-r--r--src/pkg/exp/gui/Makefile (renamed from src/pkg/exp/draw/Makefile)5
-rw-r--r--src/pkg/exp/gui/gui.go (renamed from src/pkg/exp/draw/event.go)6
-rw-r--r--src/pkg/exp/gui/x11/Makefile (renamed from src/pkg/exp/draw/x11/Makefile)2
-rw-r--r--src/pkg/exp/gui/x11/auth.go (renamed from src/pkg/exp/draw/x11/auth.go)0
-rw-r--r--src/pkg/exp/gui/x11/conn.go (renamed from src/pkg/exp/draw/x11/conn.go)31
-rw-r--r--src/pkg/exp/wingui/Makefile2
-rw-r--r--src/pkg/exp/wingui/winapi.go6
-rw-r--r--src/pkg/exp/wingui/zwinapi.go2
15 files changed, 36 insertions, 625 deletions
diff --git a/src/pkg/exp/datafmt/datafmt.go b/src/pkg/exp/datafmt/datafmt.go
index a8efdc58f..10e4b54f9 100644
--- a/src/pkg/exp/datafmt/datafmt.go
+++ b/src/pkg/exp/datafmt/datafmt.go
@@ -594,7 +594,7 @@ func (s *State) eval(fexpr expr, value reflect.Value, index int) bool {
s.eval(t.indent, value, index)
// if the indentation evaluates to nil, the state's output buffer
// didn't change - either way it's ok to append the difference to
- // the current identation
+ // the current indentation
s.indent.Write(s.output.Bytes()[mark.outputLen:s.output.Len()])
s.restore(mark)
diff --git a/src/pkg/exp/draw/draw.go b/src/pkg/exp/draw/draw.go
deleted file mode 100644
index 1d0729d92..000000000
--- a/src/pkg/exp/draw/draw.go
+++ /dev/null
@@ -1,363 +0,0 @@
-// Copyright 2009 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.
-
-// Package draw provides basic graphics and drawing primitives,
-// in the style of the Plan 9 graphics library
-// (see http://plan9.bell-labs.com/magic/man2html/2/draw)
-// and the X Render extension.
-package draw
-
-import "image"
-
-// m is the maximum color value returned by image.Color.RGBA.
-const m = 1<<16 - 1
-
-// A Porter-Duff compositing operator.
-type Op int
-
-const (
- // Over specifies ``(src in mask) over dst''.
- Over Op = iota
- // Src specifies ``src in mask''.
- Src
-)
-
-var zeroColor image.Color = image.AlphaColor{0}
-
-// A draw.Image is an image.Image with a Set method to change a single pixel.
-type Image interface {
- image.Image
- Set(x, y int, c image.Color)
-}
-
-// Draw calls DrawMask with a nil mask and an Over op.
-func Draw(dst Image, r image.Rectangle, src image.Image, sp image.Point) {
- DrawMask(dst, r, src, sp, nil, image.ZP, Over)
-}
-
-// DrawMask aligns r.Min in dst with sp in src and mp in mask and then replaces the rectangle r
-// in dst with the result of a Porter-Duff composition. A nil mask is treated as opaque.
-func DrawMask(dst Image, r image.Rectangle, src image.Image, sp image.Point, mask image.Image, mp image.Point, op Op) {
- sb := src.Bounds()
- dx, dy := sb.Max.X-sp.X, sb.Max.Y-sp.Y
- if mask != nil {
- mb := mask.Bounds()
- if dx > mb.Max.X-mp.X {
- dx = mb.Max.X - mp.X
- }
- if dy > mb.Max.Y-mp.Y {
- dy = mb.Max.Y - mp.Y
- }
- }
- if r.Dx() > dx {
- r.Max.X = r.Min.X + dx
- }
- if r.Dy() > dy {
- r.Max.Y = r.Min.Y + dy
- }
- r = r.Intersect(dst.Bounds())
- if r.Empty() {
- return
- }
-
- // Fast paths for special cases. If none of them apply, then we fall back to a general but slow implementation.
- if dst0, ok := dst.(*image.RGBA); ok {
- if op == Over {
- if mask == nil {
- if src0, ok := src.(*image.ColorImage); ok {
- drawFillOver(dst0, r, src0)
- return
- }
- if src0, ok := src.(*image.RGBA); ok {
- drawCopyOver(dst0, r, src0, sp)
- return
- }
- } else if mask0, ok := mask.(*image.Alpha); ok {
- if src0, ok := src.(*image.ColorImage); ok {
- drawGlyphOver(dst0, r, src0, mask0, mp)
- return
- }
- }
- } else {
- if mask == nil {
- if src0, ok := src.(*image.ColorImage); ok {
- drawFillSrc(dst0, r, src0)
- return
- }
- if src0, ok := src.(*image.RGBA); ok {
- drawCopySrc(dst0, r, src0, sp)
- return
- }
- }
- }
- drawRGBA(dst0, r, src, sp, mask, mp, op)
- return
- }
-
- x0, x1, dx := r.Min.X, r.Max.X, 1
- y0, y1, dy := r.Min.Y, r.Max.Y, 1
- if image.Image(dst) == src && r.Overlaps(r.Add(sp.Sub(r.Min))) {
- // Rectangles overlap: process backward?
- if sp.Y < r.Min.Y || sp.Y == r.Min.Y && sp.X < r.Min.X {
- x0, x1, dx = x1-1, x0-1, -1
- y0, y1, dy = y1-1, y0-1, -1
- }
- }
-
- var out *image.RGBA64Color
- sy := sp.Y + y0 - r.Min.Y
- my := mp.Y + y0 - r.Min.Y
- for y := y0; y != y1; y, sy, my = y+dy, sy+dy, my+dy {
- sx := sp.X + x0 - r.Min.X
- mx := mp.X + x0 - r.Min.X
- for x := x0; x != x1; x, sx, mx = x+dx, sx+dx, mx+dx {
- ma := uint32(m)
- if mask != nil {
- _, _, _, ma = mask.At(mx, my).RGBA()
- }
- switch {
- case ma == 0:
- if op == Over {
- // No-op.
- } else {
- dst.Set(x, y, zeroColor)
- }
- case ma == m && op == Src:
- dst.Set(x, y, src.At(sx, sy))
- default:
- sr, sg, sb, sa := src.At(sx, sy).RGBA()
- if out == nil {
- out = new(image.RGBA64Color)
- }
- if op == Over {
- dr, dg, db, da := dst.At(x, y).RGBA()
- a := m - (sa * ma / m)
- out.R = uint16((dr*a + sr*ma) / m)
- out.G = uint16((dg*a + sg*ma) / m)
- out.B = uint16((db*a + sb*ma) / m)
- out.A = uint16((da*a + sa*ma) / m)
- } else {
- out.R = uint16(sr * ma / m)
- out.G = uint16(sg * ma / m)
- out.B = uint16(sb * ma / m)
- out.A = uint16(sa * ma / m)
- }
- dst.Set(x, y, out)
- }
- }
- }
-}
-
-func drawFillOver(dst *image.RGBA, r image.Rectangle, src *image.ColorImage) {
- cr, cg, cb, ca := src.RGBA()
- // The 0x101 is here for the same reason as in drawRGBA.
- a := (m - ca) * 0x101
- x0, x1 := r.Min.X, r.Max.X
- y0, y1 := r.Min.Y, r.Max.Y
- for y := y0; y != y1; y++ {
- dbase := y * dst.Stride
- dpix := dst.Pix[dbase+x0 : dbase+x1]
- for i, rgba := range dpix {
- dr := (uint32(rgba.R)*a)/m + cr
- dg := (uint32(rgba.G)*a)/m + cg
- db := (uint32(rgba.B)*a)/m + cb
- da := (uint32(rgba.A)*a)/m + ca
- dpix[i] = image.RGBAColor{uint8(dr >> 8), uint8(dg >> 8), uint8(db >> 8), uint8(da >> 8)}
- }
- }
-}
-
-func drawCopyOver(dst *image.RGBA, r image.Rectangle, src *image.RGBA, sp image.Point) {
- dx0, dx1 := r.Min.X, r.Max.X
- dy0, dy1 := r.Min.Y, r.Max.Y
- nrows := dy1 - dy0
- sx0, sx1 := sp.X, sp.X+dx1-dx0
- d0 := dy0*dst.Stride + dx0
- d1 := dy0*dst.Stride + dx1
- s0 := sp.Y*src.Stride + sx0
- s1 := sp.Y*src.Stride + sx1
- var (
- ddelta, sdelta int
- i0, i1, idelta int
- )
- if r.Min.Y < sp.Y || r.Min.Y == sp.Y && r.Min.X <= sp.X {
- ddelta = dst.Stride
- sdelta = src.Stride
- i0, i1, idelta = 0, d1-d0, +1
- } else {
- // If the source start point is higher than the destination start point, or equal height but to the left,
- // then we compose the rows in right-to-left, bottom-up order instead of left-to-right, top-down.
- d0 += (nrows - 1) * dst.Stride
- d1 += (nrows - 1) * dst.Stride
- s0 += (nrows - 1) * src.Stride
- s1 += (nrows - 1) * src.Stride
- ddelta = -dst.Stride
- sdelta = -src.Stride
- i0, i1, idelta = d1-d0-1, -1, -1
- }
- for ; nrows > 0; nrows-- {
- dpix := dst.Pix[d0:d1]
- spix := src.Pix[s0:s1]
- for i := i0; i != i1; i += idelta {
- // For unknown reasons, even though both dpix[i] and spix[i] are
- // image.RGBAColors, on an x86 CPU it seems fastest to call RGBA
- // for the source but to do it manually for the destination.
- sr, sg, sb, sa := spix[i].RGBA()
- rgba := dpix[i]
- dr := uint32(rgba.R)
- dg := uint32(rgba.G)
- db := uint32(rgba.B)
- da := uint32(rgba.A)
- // The 0x101 is here for the same reason as in drawRGBA.
- a := (m - sa) * 0x101
- dr = (dr*a)/m + sr
- dg = (dg*a)/m + sg
- db = (db*a)/m + sb
- da = (da*a)/m + sa
- dpix[i] = image.RGBAColor{uint8(dr >> 8), uint8(dg >> 8), uint8(db >> 8), uint8(da >> 8)}
- }
- d0 += ddelta
- d1 += ddelta
- s0 += sdelta
- s1 += sdelta
- }
-}
-
-func drawGlyphOver(dst *image.RGBA, r image.Rectangle, src *image.ColorImage, mask *image.Alpha, mp image.Point) {
- x0, x1 := r.Min.X, r.Max.X
- y0, y1 := r.Min.Y, r.Max.Y
- cr, cg, cb, ca := src.RGBA()
- for y, my := y0, mp.Y; y != y1; y, my = y+1, my+1 {
- dbase := y * dst.Stride
- dpix := dst.Pix[dbase+x0 : dbase+x1]
- mbase := my * mask.Stride
- mpix := mask.Pix[mbase+mp.X:]
- for i, rgba := range dpix {
- ma := uint32(mpix[i].A)
- if ma == 0 {
- continue
- }
- ma |= ma << 8
- dr := uint32(rgba.R)
- dg := uint32(rgba.G)
- db := uint32(rgba.B)
- da := uint32(rgba.A)
- // The 0x101 is here for the same reason as in drawRGBA.
- a := (m - (ca * ma / m)) * 0x101
- dr = (dr*a + cr*ma) / m
- dg = (dg*a + cg*ma) / m
- db = (db*a + cb*ma) / m
- da = (da*a + ca*ma) / m
- dpix[i] = image.RGBAColor{uint8(dr >> 8), uint8(dg >> 8), uint8(db >> 8), uint8(da >> 8)}
- }
- }
-}
-
-func drawFillSrc(dst *image.RGBA, r image.Rectangle, src *image.ColorImage) {
- if r.Dy() < 1 {
- return
- }
- cr, cg, cb, ca := src.RGBA()
- color := image.RGBAColor{uint8(cr >> 8), uint8(cg >> 8), uint8(cb >> 8), uint8(ca >> 8)}
- // The built-in copy function is faster than a straightforward for loop to fill the destination with
- // the color, but copy requires a slice source. We therefore use a for loop to fill the first row, and
- // then use the first row as the slice source for the remaining rows.
- dx0, dx1 := r.Min.X, r.Max.X
- dy0, dy1 := r.Min.Y, r.Max.Y
- dbase := dy0 * dst.Stride
- i0, i1 := dbase+dx0, dbase+dx1
- firstRow := dst.Pix[i0:i1]
- for i := range firstRow {
- firstRow[i] = color
- }
- for y := dy0 + 1; y < dy1; y++ {
- i0 += dst.Stride
- i1 += dst.Stride
- copy(dst.Pix[i0:i1], firstRow)
- }
-}
-
-func drawCopySrc(dst *image.RGBA, r image.Rectangle, src *image.RGBA, sp image.Point) {
- dx0, dx1 := r.Min.X, r.Max.X
- dy0, dy1 := r.Min.Y, r.Max.Y
- nrows := dy1 - dy0
- sx0, sx1 := sp.X, sp.X+dx1-dx0
- d0 := dy0*dst.Stride + dx0
- d1 := dy0*dst.Stride + dx1
- s0 := sp.Y*src.Stride + sx0
- s1 := sp.Y*src.Stride + sx1
- var ddelta, sdelta int
- if r.Min.Y <= sp.Y {
- ddelta = dst.Stride
- sdelta = src.Stride
- } else {
- // If the source start point is higher than the destination start point, then we compose the rows
- // in bottom-up order instead of top-down. Unlike the drawCopyOver function, we don't have to
- // check the x co-ordinates because the built-in copy function can handle overlapping slices.
- d0 += (nrows - 1) * dst.Stride
- d1 += (nrows - 1) * dst.Stride
- s0 += (nrows - 1) * src.Stride
- s1 += (nrows - 1) * src.Stride
- ddelta = -dst.Stride
- sdelta = -src.Stride
- }
- for ; nrows > 0; nrows-- {
- copy(dst.Pix[d0:d1], src.Pix[s0:s1])
- d0 += ddelta
- d1 += ddelta
- s0 += sdelta
- s1 += sdelta
- }
-}
-
-func drawRGBA(dst *image.RGBA, r image.Rectangle, src image.Image, sp image.Point, mask image.Image, mp image.Point, op Op) {
- x0, x1, dx := r.Min.X, r.Max.X, 1
- y0, y1, dy := r.Min.Y, r.Max.Y, 1
- if image.Image(dst) == src && r.Overlaps(r.Add(sp.Sub(r.Min))) {
- if sp.Y < r.Min.Y || sp.Y == r.Min.Y && sp.X < r.Min.X {
- x0, x1, dx = x1-1, x0-1, -1
- y0, y1, dy = y1-1, y0-1, -1
- }
- }
-
- sy := sp.Y + y0 - r.Min.Y
- my := mp.Y + y0 - r.Min.Y
- for y := y0; y != y1; y, sy, my = y+dy, sy+dy, my+dy {
- sx := sp.X + x0 - r.Min.X
- mx := mp.X + x0 - r.Min.X
- dpix := dst.Pix[y*dst.Stride : (y+1)*dst.Stride]
- for x := x0; x != x1; x, sx, mx = x+dx, sx+dx, mx+dx {
- ma := uint32(m)
- if mask != nil {
- _, _, _, ma = mask.At(mx, my).RGBA()
- }
- sr, sg, sb, sa := src.At(sx, sy).RGBA()
- var dr, dg, db, da uint32
- if op == Over {
- rgba := dpix[x]
- dr = uint32(rgba.R)
- dg = uint32(rgba.G)
- db = uint32(rgba.B)
- da = uint32(rgba.A)
- // dr, dg, db and da are all 8-bit color at the moment, ranging in [0,255].
- // We work in 16-bit color, and so would normally do:
- // dr |= dr << 8
- // and similarly for dg, db and da, but instead we multiply a
- // (which is a 16-bit color, ranging in [0,65535]) by 0x101.
- // This yields the same result, but is fewer arithmetic operations.
- a := (m - (sa * ma / m)) * 0x101
- dr = (dr*a + sr*ma) / m
- dg = (dg*a + sg*ma) / m
- db = (db*a + sb*ma) / m
- da = (da*a + sa*ma) / m
- } else {
- dr = sr * ma / m
- dg = sg * ma / m
- db = sb * ma / m
- da = sa * ma / m
- }
- dpix[x] = image.RGBAColor{uint8(dr >> 8), uint8(dg >> 8), uint8(db >> 8), uint8(da >> 8)}
- }
- }
-}
diff --git a/src/pkg/exp/draw/draw_test.go b/src/pkg/exp/draw/draw_test.go
deleted file mode 100644
index 90c9e823d..000000000
--- a/src/pkg/exp/draw/draw_test.go
+++ /dev/null
@@ -1,228 +0,0 @@
-// Copyright 2010 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.
-
-package draw
-
-import (
- "image"
- "testing"
-)
-
-func eq(c0, c1 image.Color) bool {
- r0, g0, b0, a0 := c0.RGBA()
- r1, g1, b1, a1 := c1.RGBA()
- return r0 == r1 && g0 == g1 && b0 == b1 && a0 == a1
-}
-
-func fillBlue(alpha int) image.Image {
- return image.NewColorImage(image.RGBAColor{0, 0, uint8(alpha), uint8(alpha)})
-}
-
-func fillAlpha(alpha int) image.Image {
- return image.NewColorImage(image.AlphaColor{uint8(alpha)})
-}
-
-func vgradGreen(alpha int) image.Image {
- m := image.NewRGBA(16, 16)
- for y := 0; y < 16; y++ {
- for x := 0; x < 16; x++ {
- m.Set(x, y, image.RGBAColor{0, uint8(y * alpha / 15), 0, uint8(alpha)})
- }
- }
- return m
-}
-
-func vgradAlpha(alpha int) image.Image {
- m := image.NewAlpha(16, 16)
- for y := 0; y < 16; y++ {
- for x := 0; x < 16; x++ {
- m.Set(x, y, image.AlphaColor{uint8(y * alpha / 15)})
- }
- }
- return m
-}
-
-func hgradRed(alpha int) Image {
- m := image.NewRGBA(16, 16)
- for y := 0; y < 16; y++ {
- for x := 0; x < 16; x++ {
- m.Set(x, y, image.RGBAColor{uint8(x * alpha / 15), 0, 0, uint8(alpha)})
- }
- }
- return m
-}
-
-func gradYellow(alpha int) Image {
- m := image.NewRGBA(16, 16)
- for y := 0; y < 16; y++ {
- for x := 0; x < 16; x++ {
- m.Set(x, y, image.RGBAColor{uint8(x * alpha / 15), uint8(y * alpha / 15), 0, uint8(alpha)})
- }
- }
- return m
-}
-
-type drawTest struct {
- desc string
- src image.Image
- mask image.Image
- op Op
- expected image.Color
-}
-
-var drawTests = []drawTest{
- // Uniform mask (0% opaque).
- {"nop", vgradGreen(255), fillAlpha(0), Over, image.RGBAColor{136, 0, 0, 255}},
- {"clear", vgradGreen(255), fillAlpha(0), Src, image.RGBAColor{0, 0, 0, 0}},
- // Uniform mask (100%, 75%, nil) and uniform source.
- // At (x, y) == (8, 8):
- // The destination pixel is {136, 0, 0, 255}.
- // The source pixel is {0, 0, 90, 90}.
- {"fill", fillBlue(90), fillAlpha(255), Over, image.RGBAColor{88, 0, 90, 255}},
- {"fillSrc", fillBlue(90), fillAlpha(255), Src, image.RGBAColor{0, 0, 90, 90}},
- {"fillAlpha", fillBlue(90), fillAlpha(192), Over, image.RGBAColor{100, 0, 68, 255}},
- {"fillAlphaSrc", fillBlue(90), fillAlpha(192), Src, image.RGBAColor{0, 0, 68, 68}},
- {"fillNil", fillBlue(90), nil, Over, image.RGBAColor{88, 0, 90, 255}},
- {"fillNilSrc", fillBlue(90), nil, Src, image.RGBAColor{0, 0, 90, 90}},
- // Uniform mask (100%, 75%, nil) and variable source.
- // At (x, y) == (8, 8):
- // The destination pixel is {136, 0, 0, 255}.
- // The source pixel is {0, 48, 0, 90}.
- {"copy", vgradGreen(90), fillAlpha(255), Over, image.RGBAColor{88, 48, 0, 255}},
- {"copySrc", vgradGreen(90), fillAlpha(255), Src, image.RGBAColor{0, 48, 0, 90}},
- {"copyAlpha", vgradGreen(90), fillAlpha(192), Over, image.RGBAColor{100, 36, 0, 255}},
- {"copyAlphaSrc", vgradGreen(90), fillAlpha(192), Src, image.RGBAColor{0, 36, 0, 68}},
- {"copyNil", vgradGreen(90), nil, Over, image.RGBAColor{88, 48, 0, 255}},
- {"copyNilSrc", vgradGreen(90), nil, Src, image.RGBAColor{0, 48, 0, 90}},
- // Variable mask and variable source.
- // At (x, y) == (8, 8):
- // The destination pixel is {136, 0, 0, 255}.
- // The source pixel is {0, 0, 255, 255}.
- // The mask pixel's alpha is 102, or 40%.
- {"generic", fillBlue(255), vgradAlpha(192), Over, image.RGBAColor{81, 0, 102, 255}},
- {"genericSrc", fillBlue(255), vgradAlpha(192), Src, image.RGBAColor{0, 0, 102, 102}},
-}
-
-func makeGolden(dst, src, mask image.Image, op Op) image.Image {
- // Since golden is a newly allocated image, we don't have to check if the
- // input source and mask images and the output golden image overlap.
- b := dst.Bounds()
- sx0 := src.Bounds().Min.X - b.Min.X
- sy0 := src.Bounds().Min.Y - b.Min.Y
- var mx0, my0 int
- if mask != nil {
- mx0 = mask.Bounds().Min.X - b.Min.X
- my0 = mask.Bounds().Min.Y - b.Min.Y
- }
- golden := image.NewRGBA(b.Max.X, b.Max.Y)
- for y := b.Min.Y; y < b.Max.Y; y++ {
- my, sy := my0+y, sy0+y
- for x := b.Min.X; x < b.Max.X; x++ {
- mx, sx := mx0+x, sx0+x
- const M = 1<<16 - 1
- var dr, dg, db, da uint32
- if op == Over {
- dr, dg, db, da = dst.At(x, y).RGBA()
- }
- sr, sg, sb, sa := src.At(sx, sy).RGBA()
- ma := uint32(M)
- if mask != nil {
- _, _, _, ma = mask.At(mx, my).RGBA()
- }
- a := M - (sa * ma / M)
- golden.Set(x, y, image.RGBA64Color{
- uint16((dr*a + sr*ma) / M),
- uint16((dg*a + sg*ma) / M),
- uint16((db*a + sb*ma) / M),
- uint16((da*a + sa*ma) / M),
- })
- }
- }
- golden.Rect = b
- return golden
-}
-
-func TestDraw(t *testing.T) {
-loop:
- for _, test := range drawTests {
- dst := hgradRed(255)
- // Draw the (src, mask, op) onto a copy of dst using a slow but obviously correct implementation.
- golden := makeGolden(dst, test.src, test.mask, test.op)
- b := dst.Bounds()
- if !b.Eq(golden.Bounds()) {
- t.Errorf("draw %s: bounds %v versus %v", test.desc, dst.Bounds(), golden.Bounds())
- continue
- }
- // Draw the same combination onto the actual dst using the optimized DrawMask implementation.
- DrawMask(dst, b, test.src, image.ZP, test.mask, image.ZP, test.op)
- // Check that the resultant pixel at (8, 8) matches what we expect
- // (the expected value can be verified by hand).
- if !eq(dst.At(8, 8), test.expected) {
- t.Errorf("draw %s: at (8, 8) %v versus %v", test.desc, dst.At(8, 8), test.expected)
- continue
- }
- // Check that the resultant dst image matches the golden output.
- for y := b.Min.Y; y < b.Max.Y; y++ {
- for x := b.Min.X; x < b.Max.X; x++ {
- if !eq(dst.At(x, y), golden.At(x, y)) {
- t.Errorf("draw %s: at (%d, %d), %v versus golden %v", test.desc, x, y, dst.At(x, y), golden.At(x, y))
- continue loop
- }
- }
- }
- }
-}
-
-func TestDrawOverlap(t *testing.T) {
- for _, op := range []Op{Over, Src} {
- for yoff := -2; yoff <= 2; yoff++ {
- loop:
- for xoff := -2; xoff <= 2; xoff++ {
- m := gradYellow(127).(*image.RGBA)
- dst := &image.RGBA{
- Pix: m.Pix,
- Stride: m.Stride,
- Rect: image.Rect(5, 5, 10, 10),
- }
- src := &image.RGBA{
- Pix: m.Pix,
- Stride: m.Stride,
- Rect: image.Rect(5+xoff, 5+yoff, 10+xoff, 10+yoff),
- }
- // Draw the (src, mask, op) onto a copy of dst using a slow but obviously correct implementation.
- golden := makeGolden(dst, src, nil, op)
- b := dst.Bounds()
- if !b.Eq(golden.Bounds()) {
- t.Errorf("drawOverlap xoff=%d,yoff=%d: bounds %v versus %v", xoff, yoff, dst.Bounds(), golden.Bounds())
- continue
- }
- // Draw the same combination onto the actual dst using the optimized DrawMask implementation.
- DrawMask(dst, b, src, src.Bounds().Min, nil, image.ZP, op)
- // Check that the resultant dst image matches the golden output.
- for y := b.Min.Y; y < b.Max.Y; y++ {
- for x := b.Min.X; x < b.Max.X; x++ {
- if !eq(dst.At(x, y), golden.At(x, y)) {
- t.Errorf("drawOverlap xoff=%d,yoff=%d: at (%d, %d), %v versus golden %v", xoff, yoff, x, y, dst.At(x, y), golden.At(x, y))
- continue loop
- }
- }
- }
- }
- }
- }
-}
-
-// TestIssue836 verifies http://code.google.com/p/go/issues/detail?id=836.
-func TestIssue836(t *testing.T) {
- a := image.NewRGBA(1, 1)
- b := image.NewRGBA(2, 2)
- b.Set(0, 0, image.RGBAColor{0, 0, 0, 5})
- b.Set(1, 0, image.RGBAColor{0, 0, 5, 5})
- b.Set(0, 1, image.RGBAColor{0, 5, 0, 5})
- b.Set(1, 1, image.RGBAColor{5, 0, 0, 5})
- Draw(a, image.Rect(0, 0, 1, 1), b, image.Pt(1, 1))
- if !eq(image.RGBAColor{5, 0, 0, 5}, a.At(0, 0)) {
- t.Errorf("Issue 836: want %v got %v", image.RGBAColor{5, 0, 0, 5}, a.At(0, 0))
- }
-}
diff --git a/src/pkg/exp/eval/expr.go b/src/pkg/exp/eval/expr.go
index e65f47617..14a0659b6 100644
--- a/src/pkg/exp/eval/expr.go
+++ b/src/pkg/exp/eval/expr.go
@@ -1781,7 +1781,7 @@ func (a *exprInfo) compileBinaryExpr(op token.Token, l, r *expr) *expr {
// written: Function values are equal if they were
// created by the same execution of a function literal
// or refer to the same function declaration. This is
- // *almost* but not quite waht 6g implements. If a
+ // *almost* but not quite what 6g implements. If a
// function literals does not capture any variables,
// then multiple executions of it will result in the
// same closure. Russ says he'll change that.
diff --git a/src/pkg/exp/eval/gen.go b/src/pkg/exp/eval/gen.go
index de98a5d15..1e00bdcd0 100644
--- a/src/pkg/exp/eval/gen.go
+++ b/src/pkg/exp/eval/gen.go
@@ -366,10 +366,10 @@ func main() {
t.SetDelims("«", "»")
err := t.Parse(templateStr)
if err != nil {
- log.Exit(err)
+ log.Fatal(err)
}
err = t.Execute(os.Stdout, data)
if err != nil {
- log.Exit(err)
+ log.Fatal(err)
}
}
diff --git a/src/pkg/exp/eval/stmt.go b/src/pkg/exp/eval/stmt.go
index f6b7c1cda..57bf20e6f 100644
--- a/src/pkg/exp/eval/stmt.go
+++ b/src/pkg/exp/eval/stmt.go
@@ -68,7 +68,7 @@ type flowBuf struct {
gotos map[token.Pos]*flowBlock
// labels is a map from label name to information on the block
// at the point of the label. labels are tracked by name,
- // since mutliple labels at the same PC can have different
+ // since multiple labels at the same PC can have different
// blocks.
labels map[string]*flowBlock
}
@@ -307,7 +307,7 @@ func (a *stmtCompiler) compile(s ast.Stmt) {
}
if notimpl {
- a.diag("%T statment node not implemented", s)
+ a.diag("%T statement node not implemented", s)
}
if a.block.inner != nil {
@@ -550,7 +550,7 @@ func (a *stmtCompiler) doAssign(lhs []ast.Expr, rhs []ast.Expr, tok token.Token,
ident, ok = le.(*ast.Ident)
if !ok {
a.diagAt(le.Pos(), "left side of := must be a name")
- // Suppress new defitions errors
+ // Suppress new definitions errors
nDefs++
continue
}
diff --git a/src/pkg/exp/eval/typec.go b/src/pkg/exp/eval/typec.go
index de90cf664..0ed24a8d2 100644
--- a/src/pkg/exp/eval/typec.go
+++ b/src/pkg/exp/eval/typec.go
@@ -68,7 +68,7 @@ func (a *typeCompiler) compileArrayType(x *ast.ArrayType, allowRec bool) Type {
}
if _, ok := x.Len.(*ast.Ellipsis); ok {
- a.diagAt(x.Len.Pos(), "... array initailizers not implemented")
+ a.diagAt(x.Len.Pos(), "... array initializers not implemented")
return nil
}
l, ok := a.compileArrayLen(a.block, x.Len)
diff --git a/src/pkg/exp/draw/Makefile b/src/pkg/exp/gui/Makefile
index 6f0f0b2f5..af065e4a5 100644
--- a/src/pkg/exp/draw/Makefile
+++ b/src/pkg/exp/gui/Makefile
@@ -4,9 +4,8 @@
include ../../../Make.inc
-TARG=exp/draw
+TARG=exp/gui
GOFILES=\
- draw.go\
- event.go\
+ gui.go\
include ../../../Make.pkg
diff --git a/src/pkg/exp/draw/event.go b/src/pkg/exp/gui/gui.go
index b777d912e..171499186 100644
--- a/src/pkg/exp/draw/event.go
+++ b/src/pkg/exp/gui/gui.go
@@ -2,17 +2,19 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-package draw
+// Package gui defines a basic graphical user interface programming model.
+package gui
import (
"image"
+ "image/draw"
"os"
)
// A Window represents a single graphics window.
type Window interface {
// Screen returns an editable Image for the window.
- Screen() Image
+ Screen() draw.Image
// FlushImage flushes changes made to Screen() back to screen.
FlushImage()
// EventChan returns a channel carrying UI events such as key presses,
diff --git a/src/pkg/exp/draw/x11/Makefile b/src/pkg/exp/gui/x11/Makefile
index 205b3a65b..88cc1e23b 100644
--- a/src/pkg/exp/draw/x11/Makefile
+++ b/src/pkg/exp/gui/x11/Makefile
@@ -4,7 +4,7 @@
include ../../../../Make.inc
-TARG=exp/draw/x11
+TARG=exp/gui/x11
GOFILES=\
auth.go\
conn.go\
diff --git a/src/pkg/exp/draw/x11/auth.go b/src/pkg/exp/gui/x11/auth.go
index d48936ac1..d48936ac1 100644
--- a/src/pkg/exp/draw/x11/auth.go
+++ b/src/pkg/exp/gui/x11/auth.go
diff --git a/src/pkg/exp/draw/x11/conn.go b/src/pkg/exp/gui/x11/conn.go
index 81c67267d..bc7ca63db 100644
--- a/src/pkg/exp/draw/x11/conn.go
+++ b/src/pkg/exp/gui/x11/conn.go
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// Package x11 implements an X11 backend for the exp/draw package.
+// Package x11 implements an X11 backend for the exp/gui package.
//
// The X protocol specification is at ftp://ftp.x.org/pub/X11R7.0/doc/PDF/proto.pdf.
// A summary of the wire format can be found in XCB's xproto.xml.
@@ -10,8 +10,9 @@ package x11
import (
"bufio"
- "exp/draw"
+ "exp/gui"
"image"
+ "image/draw"
"io"
"log"
"net"
@@ -43,7 +44,7 @@ type conn struct {
img *image.RGBA
eventc chan interface{}
- mouseState draw.MouseEvent
+ mouseState gui.MouseEvent
buf [256]byte // General purpose scratch buffer.
@@ -53,7 +54,7 @@ type conn struct {
}
// writeSocket runs in its own goroutine, serving both FlushImage calls
-// directly from the exp/draw client and indirectly from X expose events.
+// directly from the exp/gui client and indirectly from X expose events.
// It paints c.img to the X server via PutImage requests.
func (c *conn) writeSocket() {
defer c.c.Close()
@@ -143,7 +144,7 @@ func (c *conn) Close() os.Error {
func (c *conn) EventChan() <-chan interface{} { return c.eventc }
-// readSocket runs in its own goroutine, reading X events and sending draw
+// readSocket runs in its own goroutine, reading X events and sending gui
// events on c's EventChan.
func (c *conn) readSocket() {
var (
@@ -155,7 +156,7 @@ func (c *conn) readSocket() {
// X events are always 32 bytes long.
if _, err := io.ReadFull(c.r, c.buf[0:32]); err != nil {
if err != os.EOF {
- c.eventc <- draw.ErrEvent{err}
+ c.eventc <- gui.ErrEvent{err}
}
return
}
@@ -165,7 +166,7 @@ func (c *conn) readSocket() {
if cookie != 1 {
// We issued only one request (GetKeyboardMapping) with a cookie of 1,
// so we shouldn't get any other reply from the X server.
- c.eventc <- draw.ErrEvent{os.NewError("x11: unexpected cookie")}
+ c.eventc <- gui.ErrEvent{os.NewError("x11: unexpected cookie")}
return
}
keysymsPerKeycode = int(c.buf[1])
@@ -179,7 +180,7 @@ func (c *conn) readSocket() {
u, err := readU32LE(c.r, c.buf[0:4])
if err != nil {
if err != os.EOF {
- c.eventc <- draw.ErrEvent{err}
+ c.eventc <- gui.ErrEvent{err}
}
return
}
@@ -204,11 +205,11 @@ func (c *conn) readSocket() {
// TODO(nigeltao): Should we send KeyEvents for Shift/Ctrl/Alt? Should Shift-A send
// the same int down the channel as the sent on just the A key?
// TODO(nigeltao): How should IME events (e.g. key presses that should generate CJK text) work? Or
- // is that outside the scope of the draw.Window interface?
+ // is that outside the scope of the gui.Window interface?
if c.buf[0] == 0x03 {
keysym = -keysym
}
- c.eventc <- draw.KeyEvent{keysym}
+ c.eventc <- gui.KeyEvent{keysym}
case 0x04, 0x05: // Button press, button release.
mask := 1 << (c.buf[1] - 1)
if c.buf[0] == 0x04 {
@@ -310,7 +311,7 @@ func authenticate(w *bufio.Writer, displayStr string) os.Error {
return os.NewError("unsupported Xauth")
}
// 0x006c means little-endian. 0x000b, 0x0000 means X major version 11, minor version 0.
- // 0x0012 and 0x0010 means the auth key and value have lenths 18 and 16.
+ // 0x0012 and 0x0010 means the auth key and value have lengths 18 and 16.
// The final 0x0000 is padding, so that the string length is a multiple of 4.
_, err = io.WriteString(w, "\x6c\x00\x0b\x00\x00\x00\x12\x00\x10\x00\x00\x00")
if err != nil {
@@ -517,7 +518,7 @@ func (c *conn) handshake() os.Error {
if err != nil {
return err
}
- // Ignore some things that we don't care about (totalling 10 + vendorLen bytes):
+ // Ignore some things that we don't care about (totaling 10 + vendorLen bytes):
// imageByteOrder(1), bitmapFormatBitOrder(1), bitmapFormatScanlineUnit(1) bitmapFormatScanlinePad(1),
// minKeycode(1), maxKeycode(1), padding(4), vendor (vendorLen).
if 10+int(vendorLen) > cap(c.buf) {
@@ -551,7 +552,7 @@ func (c *conn) handshake() os.Error {
}
// NewWindow calls NewWindowDisplay with $DISPLAY.
-func NewWindow() (draw.Window, os.Error) {
+func NewWindow() (gui.Window, os.Error) {
display := os.Getenv("DISPLAY")
if len(display) == 0 {
return nil, os.NewError("$DISPLAY not set")
@@ -559,10 +560,10 @@ func NewWindow() (draw.Window, os.Error) {
return NewWindowDisplay(display)
}
-// NewWindowDisplay returns a new draw.Window, backed by a newly created and
+// NewWindowDisplay returns a new gui.Window, backed by a newly created and
// mapped X11 window. The X server to connect to is specified by the display
// string, such as ":1".
-func NewWindowDisplay(display string) (draw.Window, os.Error) {
+func NewWindowDisplay(display string) (gui.Window, os.Error) {
socket, displayStr, err := connect(display)
if err != nil {
return nil, err
diff --git a/src/pkg/exp/wingui/Makefile b/src/pkg/exp/wingui/Makefile
index 983a8270b..e382c019f 100644
--- a/src/pkg/exp/wingui/Makefile
+++ b/src/pkg/exp/wingui/Makefile
@@ -18,7 +18,7 @@ GOFILES=\
include ../../../Make.cmd
zwinapi.go: winapi.go
- $(GOROOT)/src/pkg/syscall/mksyscall_windows.sh $< \
+ $(GOROOT)/src/pkg/syscall/mksyscall_windows.pl $< \
| sed 's/^package.*syscall$$/package main/' \
| sed '/^import/a \
import "syscall"' \
diff --git a/src/pkg/exp/wingui/winapi.go b/src/pkg/exp/wingui/winapi.go
index c96f45299..fb0d61009 100644
--- a/src/pkg/exp/wingui/winapi.go
+++ b/src/pkg/exp/wingui/winapi.go
@@ -96,7 +96,7 @@ const (
// Some button control styles
BS_DEFPUSHBUTTON = 1
- // Some colour constants
+ // Some color constants
COLOR_WINDOW = 5
COLOR_BTNFACE = 15
@@ -108,13 +108,13 @@ const (
)
var (
- // Some globaly known cusrors
+ // Some globally known cursors
IDC_ARROW = MakeIntResource(32512)
IDC_IBEAM = MakeIntResource(32513)
IDC_WAIT = MakeIntResource(32514)
IDC_CROSS = MakeIntResource(32515)
- // Some globaly known icons
+ // Some globally known icons
IDI_APPLICATION = MakeIntResource(32512)
IDI_HAND = MakeIntResource(32513)
IDI_QUESTION = MakeIntResource(32514)
diff --git a/src/pkg/exp/wingui/zwinapi.go b/src/pkg/exp/wingui/zwinapi.go
index 60aaac6cf..6ae6330a1 100644
--- a/src/pkg/exp/wingui/zwinapi.go
+++ b/src/pkg/exp/wingui/zwinapi.go
@@ -1,4 +1,4 @@
-// mksyscall_windows.sh winapi.go
+// mksyscall_windows.pl winapi.go
// MACHINE GENERATED BY THE COMMAND ABOVE; DO NOT EDIT
package main
generated by cgit v1.2.3 (git 2.39.1) at 2025-05-02 04:37:03 +0000