Rename UIString to TString, move ansimage to lib/ and switch to tcell fork

1 files changed, 287 insertions, 0 deletions

diff --git a/lib/ansimage/ansimage.go b/lib/ansimage/ansimage.go
new file mode 100644
index 0000000..a41c833
--- /dev/null
+++ b/lib/ansimage/ansimage.go
@@ -0,0 +1,287 @@
+//       ___  _____  ____
+//      / _ \/  _/ |/_/ /____ ______ _
+//     / ___// /_>  </ __/ -_) __/  ' \
+//    /_/  /___/_/|_|\__/\__/_/ /_/_/_/
+//
+//    Copyright 2017 Eliuk Blau
+//
+//    This Source Code Form is subject to the terms of the Mozilla Public
+//    License, v. 2.0. If a copy of the MPL was not distributed with this
+//    file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+package ansimage
+
+import (
+	"errors"
+	"image"
+	"image/color"
+	"image/draw"
+	_ "image/gif"  // initialize decoder
+	_ "image/jpeg" // initialize decoder
+	_ "image/png"  // initialize decoder
+	"io"
+	"os"
+
+	"github.com/disintegration/imaging"
+	_ "golang.org/x/image/bmp"  // initialize decoder
+	_ "golang.org/x/image/tiff" // initialize decoder
+	_ "golang.org/x/image/webp" // initialize decoder
+	"maunium.net/go/gomuks/ui/messages/tstring"
+	"maunium.net/go/tcell"
+)
+
+var (
+	// ErrHeightNonMoT happens when ANSImage height is not a Multiple of Two value.
+	ErrHeightNonMoT = errors.New("ANSImage: height must be a Multiple of Two value")
+
+	// ErrInvalidBoundsMoT happens when ANSImage height or width are invalid values (Multiple of Two).
+	ErrInvalidBoundsMoT = errors.New("ANSImage: height or width must be >=2")
+
+	// ErrOutOfBounds happens when ANSI-pixel coordinates are out of ANSImage bounds.
+	ErrOutOfBounds = errors.New("ANSImage: out of bounds")
+)
+
+// ANSIpixel represents a pixel of an ANSImage.
+type ANSIpixel struct {
+	Brightness uint8
+	R, G, B    uint8
+	upper      bool
+	source     *ANSImage
+}
+
+// ANSImage represents an image encoded in ANSI escape codes.
+type ANSImage struct {
+	h, w     int
+	maxprocs int
+	bgR      uint8
+	bgG      uint8
+	bgB      uint8
+	pixmap   [][]*ANSIpixel
+}
+
+func (ai *ANSImage) Pixmap() [][]*ANSIpixel {
+	return ai.pixmap
+}
+
+// Height gets total rows of ANSImage.
+func (ai *ANSImage) Height() int {
+	return ai.h
+}
+
+// Width gets total columns of ANSImage.
+func (ai *ANSImage) Width() int {
+	return ai.w
+}
+
+// SetMaxProcs sets the maximum number of parallel goroutines to render the ANSImage
+// (user should manually sets `runtime.GOMAXPROCS(max)` before to this change takes effect).
+func (ai *ANSImage) SetMaxProcs(max int) {
+	ai.maxprocs = max
+}
+
+// GetMaxProcs gets the maximum number of parallels goroutines to render the ANSImage.
+func (ai *ANSImage) GetMaxProcs() int {
+	return ai.maxprocs
+}
+
+// SetAt sets ANSI-pixel color (RBG) and brightness in coordinates (y,x).
+func (ai *ANSImage) SetAt(y, x int, r, g, b, brightness uint8) error {
+	if y >= 0 && y < ai.h && x >= 0 && x < ai.w {
+		ai.pixmap[y][x].R = r
+		ai.pixmap[y][x].G = g
+		ai.pixmap[y][x].B = b
+		ai.pixmap[y][x].Brightness = brightness
+		ai.pixmap[y][x].upper = y%2 == 0
+		return nil
+	}
+	return ErrOutOfBounds
+}
+
+// GetAt gets ANSI-pixel in coordinates (y,x).
+func (ai *ANSImage) GetAt(y, x int) (*ANSIpixel, error) {
+	if y >= 0 && y < ai.h && x >= 0 && x < ai.w {
+		return &ANSIpixel{
+			R:          ai.pixmap[y][x].R,
+			G:          ai.pixmap[y][x].G,
+			B:          ai.pixmap[y][x].B,
+			Brightness: ai.pixmap[y][x].Brightness,
+			upper:      ai.pixmap[y][x].upper,
+			source:     ai.pixmap[y][x].source,
+		},
+			nil
+	}
+	return nil, ErrOutOfBounds
+}
+
+// Render returns the ANSI-compatible string form of ANSImage.
+// (Nice info for ANSI True Colour - https://gist.github.com/XVilka/8346728)
+func (ai *ANSImage) Render() []tstring.TString {
+	type renderData struct {
+		row    int
+		render tstring.TString
+	}
+
+	rows := make([]tstring.TString, ai.h/2)
+	for y := 0; y < ai.h; y += ai.maxprocs {
+		ch := make(chan renderData, ai.maxprocs)
+		for n, r := 0, y+1; (n <= ai.maxprocs) && (2*r+1 < ai.h); n, r = n+1, y+n+1 {
+			go func(r, y int) {
+				str := make(tstring.TString, ai.w)
+				for x := 0; x < ai.w; x++ {
+					topPixel := ai.pixmap[y][x]
+					topColor := tcell.NewRGBColor(int32(topPixel.R), int32(topPixel.G), int32(topPixel.B))
+
+					bottomPixel := ai.pixmap[y+1][x]
+					bottomColor := tcell.NewRGBColor(int32(bottomPixel.R), int32(bottomPixel.G), int32(bottomPixel.B))
+
+					str[x] = tstring.Cell{
+						Char:  '▄',
+						Style: tcell.StyleDefault.Background(topColor).Foreground(bottomColor),
+					}
+				}
+				ch <- renderData{row: r, render: str}
+			}(r, 2*r)
+		}
+		for n, r := 0, y+1; (n <= ai.maxprocs) && (2*r+1 < ai.h); n, r = n+1, y+n+1 {
+			data := <-ch
+			rows[data.row] = data.render
+		}
+	}
+	return rows
+}
+
+// New creates a new empty ANSImage ready to draw on it.
+func New(h, w int, bg color.Color) (*ANSImage, error) {
+	if h%2 != 0 {
+		return nil, ErrHeightNonMoT
+	}
+
+	if h < 2 || w < 2 {
+		return nil, ErrInvalidBoundsMoT
+	}
+
+	r, g, b, _ := bg.RGBA()
+	ansimage := &ANSImage{
+		h:        h, w: w,
+		maxprocs: 1,
+		bgR:      uint8(r),
+		bgG:      uint8(g),
+		bgB:      uint8(b),
+		pixmap:   nil,
+	}
+
+	ansimage.pixmap = func() [][]*ANSIpixel {
+		v := make([][]*ANSIpixel, h)
+		for y := 0; y < h; y++ {
+			v[y] = make([]*ANSIpixel, w)
+			for x := 0; x < w; x++ {
+				v[y][x] = &ANSIpixel{
+					R:          0,
+					G:          0,
+					B:          0,
+					Brightness: 0,
+					source:     ansimage,
+					upper:      y%2 == 0,
+				}
+			}
+		}
+		return v
+	}()
+
+	return ansimage, nil
+}
+
+// NewFromReader creates a new ANSImage from an io.Reader.
+// Background color is used to fill when image has transparency or dithering mode is enabled
+// Dithering mode is used to specify the way that ANSImage render ANSI-pixels (char/block elements).
+func NewFromReader(reader io.Reader, bg color.Color) (*ANSImage, error) {
+	img, _, err := image.Decode(reader)
+	if err != nil {
+		return nil, err
+	}
+
+	return createANSImage(img, bg)
+}
+
+// NewScaledFromReader creates a new scaled ANSImage from an io.Reader.
+// Background color is used to fill when image has transparency or dithering mode is enabled
+// Dithering mode is used to specify the way that ANSImage render ANSI-pixels (char/block elements).
+func NewScaledFromReader(reader io.Reader, y, x int, bg color.Color) (*ANSImage, error) {
+	img, _, err := image.Decode(reader)
+	if err != nil {
+		return nil, err
+	}
+
+	img = imaging.Resize(img, x, y, imaging.Lanczos)
+
+	return createANSImage(img, bg)
+}
+
+// NewFromFile creates a new ANSImage from a file.
+// Background color is used to fill when image has transparency or dithering mode is enabled
+// Dithering mode is used to specify the way that ANSImage render ANSI-pixels (char/block elements).
+func NewFromFile(name string, bg color.Color) (*ANSImage, error) {
+	reader, err := os.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	defer reader.Close()
+	return NewFromReader(reader, bg)
+}
+
+// NewScaledFromFile creates a new scaled ANSImage from a file.
+// Background color is used to fill when image has transparency or dithering mode is enabled
+// Dithering mode is used to specify the way that ANSImage render ANSI-pixels (char/block elements).
+func NewScaledFromFile(name string, y, x int, bg color.Color) (*ANSImage, error) {
+	reader, err := os.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	defer reader.Close()
+	return NewScaledFromReader(reader, y, x, bg)
+}
+
+// createANSImage loads data from an image and returns an ANSImage.
+// Background color is used to fill when image has transparency or dithering mode is enabled
+// Dithering mode is used to specify the way that ANSImage render ANSI-pixels (char/block elements).
+func createANSImage(img image.Image, bg color.Color) (*ANSImage, error) {
+	var rgbaOut *image.RGBA
+	bounds := img.Bounds()
+
+	// do compositing only if background color has no transparency (thank you @disq for the idea!)
+	// (info - http://stackoverflow.com/questions/36595687/transparent-pixel-color-go-lang-image)
+	if _, _, _, a := bg.RGBA(); a >= 0xffff {
+		rgbaOut = image.NewRGBA(bounds)
+		draw.Draw(rgbaOut, bounds, image.NewUniform(bg), image.ZP, draw.Src)
+		draw.Draw(rgbaOut, bounds, img, image.ZP, draw.Over)
+	} else {
+		if v, ok := img.(*image.RGBA); ok {
+			rgbaOut = v
+		} else {
+			rgbaOut = image.NewRGBA(bounds)
+			draw.Draw(rgbaOut, bounds, img, image.ZP, draw.Src)
+		}
+	}
+
+	yMin, xMin := bounds.Min.Y, bounds.Min.X
+	yMax, xMax := bounds.Max.Y, bounds.Max.X
+
+	// always sets an even number of ANSIPixel rows...
+	yMax = yMax - yMax%2 // one for upper pixel and another for lower pixel --> without dithering
+
+	ansimage, err := New(yMax, xMax, bg)
+	if err != nil {
+		return nil, err
+	}
+
+	for y := yMin; y < yMax; y++ {
+		for x := xMin; x < xMax; x++ {
+			v := rgbaOut.RGBAAt(x, y)
+			if err := ansimage.SetAt(y, x, v.R, v.G, v.B, 0); err != nil {
+				return nil, err
+			}
+		}
+	}
+
+	return ansimage, nil
+}