OrgGo/termdash
1
0
Fork 0
mirror of https://github.com/mum4k/termdash.git synced 2025-04-28 13:48:51 +08:00
Code Issues Projects Releases Wiki Activity

Support addition of gaps.

Browse Source
This commit is contained in:
Jakub Sobon 2019-02-06 00:29:14 -05:00
parent 858ce17ced
commit e80e1a1134
No known key found for this signature in database
GPG Key ID: F2451A77FB05D3B7
4 changed files with 467 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
widgets/segmentdisplay/options.go
View File

@ -14,7 +14,11 @@
package segmentdisplay
import "github.com/mum4k/termdash/align"
import (
"fmt"
"github.com/mum4k/termdash/align"
)
// options.go contains configurable options for SegmentDisplay.
@ -37,6 +41,15 @@ type options struct {
hAlign align.Horizontal
vAlign align.Vertical
maximizeSegSize bool
gapPercent int
}
// validate validates the provided options.
func (o *options) validate() error {
if min, max := 0, 100; o.gapPercent < min || o.gapPercent > max {
return fmt.Errorf("invalid GapPercent %d, must be %d <= value <= %d", o.gapPercent, min, max)
}
return nil
}
// newOptions returns options with the default values set.
@ -44,6 +57,7 @@ func newOptions() *options {
return &options{
hAlign: align.HorizontalCenter,
vAlign: align.VerticalMiddle,
gapPercent: DefaultGapPercent,
}
}
@ -86,4 +100,13 @@ func MaximizeDisplayedText() Option {
})
}
// TODO: Spacing between segments in cells.
// DefaultGapPercent is the default value for the GapPercent option.
const DefaultGapPercent = 20
// GapPercent sets the size of the horizontal gap between individual segments
// (characters) expressed as a percentage of the segment height.
func GapPercent(perc int) Option {
return option(func(opts *options) {
opts.gapPercent = perc
})
}

167
widgets/segmentdisplay/segmentdisplay.go
View File

@ -58,15 +58,18 @@ type SegmentDisplay struct {
}
// New returns a new SegmentDisplay.
func New(opts ...Option) *SegmentDisplay {
func New(opts ...Option) (*SegmentDisplay, error) {
opt := newOptions()
for _, o := range opts {
o.set(opt)
}
if err := opt.validate(); err != nil {
return nil, err
}
return &SegmentDisplay{
wOptsTracker: attrrange.NewTracker(),
opts: opt,
}
}, nil
}
// TextChunk is a part of or the full text that will be displayed.
@ -93,16 +96,28 @@ func NewChunk(text string, wOpts ...WriteOption) *TextChunk {
//
// Each of the text chunks can have its own options. At least one chunk must be
// specified.
func (sd *SegmentDisplay) Write(chunks ...*TextChunk) error {
//
// Any provided options override options given to New.
func (sd *SegmentDisplay) Write(chunks []*TextChunk, opts ...Option) error {
sd.mu.Lock()
defer sd.mu.Unlock()
sd.reset()
for _, o := range opts {
o.set(sd.opts)
}
if err := sd.opts.validate(); err != nil {
return err
}
if len(chunks) == 0 {
return errors.New("at least one text chunk must be specified")
}
sd.reset()
for i, tc := range chunks {
if tc.text == "" {
return fmt.Errorf("text chunk[%d] is empty, all chunks must contains some text", i)
}
if ok, badRunes := sixteen.SupportsChars(tc.text); !ok && tc.wOpts.errOnUnsupported {
return fmt.Errorf("text chunk[%d] contains unsupported characters %v, clean the text or provide the WriteSanitize option", i, badRunes)
}
@ -134,70 +149,117 @@ func (sd *SegmentDisplay) reset() {
sd.wOptsTracker = attrrange.NewTracker()
}
// segArea given an area available for drawing returns the area required for a
// single segment and the number of segments we can fit.
func (sd *SegmentDisplay) segArea(ar image.Rectangle) (image.Rectangle, int, error) {
segAr, err := sixteen.Required(ar)
if err != nil {
return image.ZR, 0, fmt.Errorf("sixteen.Required => %v", err)
// segArea contains information about the area that will contain the segments.
type segArea struct {
// segment is the area for one segment.
segment image.Rectangle
// canFit is the number of segments we can fit on the canvas.
canFit int
// gapPixels is the size of gaps between segments in pixels.
gapPixels int
// gaps is the number of gaps that will be drawn.
gaps int
}
canFit := ar.Dx() / segAr.Dx()
return segAr, canFit, nil
// needArea returns the complete area required for all the segments that we can
// fit and any gaps.
func (sa *segArea) needArea() image.Rectangle {
return image.Rect(
0,
0,
sa.segment.Dx()*sa.canFit+sa.gaps*sa.gapPixels,
sa.segment.Dy(),
)
}
// segArea calculates size and number of segments that can fit onto the
// specified area.
func (sd *SegmentDisplay) segArea(ar image.Rectangle) (*segArea, error) {
segAr, err := sixteen.Required(ar)
if err != nil {
return nil, fmt.Errorf("sixteen.Required => %v", err)
}
gapPixels := segAr.Dy() * sd.opts.gapPercent / 100
var (
gaps int
canFit int
taken int
)
for i := 0; i < sd.buff.Len(); i++ {
taken += segAr.Dx()
if taken > ar.Dx() {
break
}
canFit++
// Don't insert gaps after the last segment in the text or the last
// segment we can fit.
if gapPixels == 0 || i == sd.buff.Len()-1 {
continue
}
remaining := ar.Dx() - taken
// Only insert gaps if we can still fit one more segment with the gap.
if remaining >= gapPixels+segAr.Dx() {
taken += gapPixels
gaps++
} else {
// Gap is needed but doesn't fit together with the next segment.
// So insert neither.
break
}
}
return &segArea{
segment: segAr,
canFit: canFit,
gapPixels: gapPixels,
gaps: gaps,
}, nil
}
// maximizeFit finds the largest individual segment size that enables us to fit
// the most characters onto a canvas with the provided area. Returns the area
// required for a single segment and the number of segments we can fit.
func (sd *SegmentDisplay) maximizeFit(ar image.Rectangle) (image.Rectangle, int, error) {
bestSegAr := image.ZR
bestCanFit := 0
func (sd *SegmentDisplay) maximizeFit(ar image.Rectangle) (*segArea, error) {
var bestSegAr *segArea
need := sd.buff.Len()
for height := ar.Dy(); height >= sixteen.MinRows; height-- {
ar := image.Rect(ar.Min.X, ar.Min.Y, ar.Max.X, ar.Min.Y+height)
segAr, canFit, err := sd.segArea(ar)
segAr, err := sd.segArea(ar)
if err != nil {
return image.ZR, 0, err
return nil, err
}
if canFit >= need {
return segAr, canFit, nil
if segAr.canFit >= need {
return segAr, nil
}
bestSegAr = segAr
bestCanFit = canFit
}
if bestSegAr.Eq(image.ZR) || bestCanFit == 0 {
return image.ZR, 0, fmt.Errorf("failed to maximize character fit for area: %v", ar)
}
return bestSegAr, bestCanFit, nil
return bestSegAr, nil
}
// preprocess determines the size of individual segments maximizing their
// height or the amount of displayed characters based on the specified options.
// Returns the area required for a single segment and the text that we can fit.
func (sd *SegmentDisplay) preprocess(cvsAr image.Rectangle) (image.Rectangle, string, error) {
segAr, canFit, err := sd.segArea(cvsAr)
// Returns the area required for a single segment, the text that we can fit and
// size of gaps between segments in cells.
func (sd *SegmentDisplay) preprocess(cvsAr image.Rectangle) (*segArea, error) {
segAr, err := sd.segArea(cvsAr)
if err != nil {
return image.ZR, "", err
return nil, err
}
text := sd.buff.String()
need := len(text)
if need <= canFit {
return segAr, text, nil
need := sd.buff.Len()
if need <= segAr.canFit || sd.opts.maximizeSegSize {
return segAr, nil
}
if sd.opts.maximizeSegSize {
return segAr, text[:canFit], nil
}
bestAr, bestFit, err := sd.maximizeFit(cvsAr)
bestAr, err := sd.maximizeFit(cvsAr)
if err != nil {
return image.ZR, "", err
return nil, err
}
return bestAr, text[:bestFit], nil
return bestAr, nil
}
// Draw draws the SegmentDisplay widget onto the canvas.
@ -210,13 +272,13 @@ func (sd *SegmentDisplay) Draw(cvs *canvas.Canvas) error {
return nil
}
segAr, text, err := sd.preprocess(cvs.Area())
segAr, err := sd.preprocess(cvs.Area())
if err != nil {
return err
}
needAr := image.Rect(0, 0, segAr.Dx()*len(text), segAr.Dy())
aligned, err := align.Rectangle(cvs.Area(), needAr, sd.opts.hAlign, sd.opts.vAlign)
text := sd.buff.String()
aligned, err := align.Rectangle(cvs.Area(), segAr.needArea(), sd.opts.hAlign, sd.opts.vAlign)
if err != nil {
return fmt.Errorf("align.Rectangle => %v", err)
}
@ -226,16 +288,25 @@ func (sd *SegmentDisplay) Draw(cvs *canvas.Canvas) error {
return err
}
gaps := segAr.gaps
startX := aligned.Min.X
for i, c := range text {
if i >= segAr.canFit {
break
}
disp := sixteen.New()
if err := disp.SetCharacter(c); err != nil {
return fmt.Errorf("disp.SetCharacter => %v", err)
}
ar := image.Rect(
aligned.Min.X+segAr.Dx()*i, aligned.Min.Y,
aligned.Min.X+segAr.Dx()*(i+1), aligned.Max.Y,
)
endX := startX + segAr.segment.Dx()
ar := image.Rect(startX, aligned.Min.Y, endX, aligned.Max.Y)
startX = endX
if gaps > 0 {
startX += segAr.gapPixels
gaps--
}
dCvs, err := canvas.New(ar)
if err != nil {

328
widgets/segmentdisplay/segmentdisplay_test.go
View File

@ -46,14 +46,53 @@ func TestSegmentDisplay(t *testing.T) {
update func(*SegmentDisplay) error // update gets called before drawing of the widget.
canvas image.Rectangle
want func(size image.Point) *faketerm.Terminal
wantNewErr bool
wantUpdateErr bool // whether to expect an error on a call to the update function
wantDrawErr bool
}{
{
desc: "New fails on invalid GapPercent (too low)",
opts: []Option{
GapPercent(-1),
},
canvas: image.Rect(0, 0, sixteen.MinCols, sixteen.MinRows),
wantNewErr: true,
},
{
desc: "New fails on invalid GapPercent (too high)",
opts: []Option{
GapPercent(101),
},
canvas: image.Rect(0, 0, sixteen.MinCols, sixteen.MinRows),
wantNewErr: true,
},
{
desc: "write fails on invalid GapPercent (too low)",
canvas: image.Rect(0, 0, sixteen.MinCols, sixteen.MinRows),
update: func(sd *SegmentDisplay) error {
return sd.Write(
[]*TextChunk{NewChunk("1")},
GapPercent(-1),
)
},
wantUpdateErr: true,
},
{
desc: "write fails on invalid GapPercent (too high)",
canvas: image.Rect(0, 0, sixteen.MinCols, sixteen.MinRows),
update: func(sd *SegmentDisplay) error {
return sd.Write(
[]*TextChunk{NewChunk("1")},
GapPercent(101),
)
},
wantUpdateErr: true,
},
{
desc: "fails on area too small for a segment",
canvas: image.Rect(0, 0, sixteen.MinCols-1, sixteen.MinRows),
update: func(sd *SegmentDisplay) error {
return sd.Write(NewChunk("1"))
return sd.Write([]*TextChunk{NewChunk("1")})
},
wantDrawErr: true,
},
@ -61,7 +100,15 @@ func TestSegmentDisplay(t *testing.T) {
desc: "write fails without chunks",
canvas: image.Rect(0, 0, sixteen.MinCols, sixteen.MinRows),
update: func(sd *SegmentDisplay) error {
return sd.Write()
return sd.Write(nil)
},
wantUpdateErr: true,
},
{
desc: "write fails with an empty chunk",
canvas: image.Rect(0, 0, sixteen.MinCols, sixteen.MinRows),
update: func(sd *SegmentDisplay) error {
return sd.Write([]*TextChunk{NewChunk("")})
},
wantUpdateErr: true,
},
@ -69,7 +116,7 @@ func TestSegmentDisplay(t *testing.T) {
desc: "write fails on unsupported characters when requested",
canvas: image.Rect(0, 0, sixteen.MinCols, sixteen.MinRows),
update: func(sd *SegmentDisplay) error {
return sd.Write(NewChunk(".", WriteErrOnUnsupported()))
return sd.Write([]*TextChunk{NewChunk(".", WriteErrOnUnsupported())})
},
wantUpdateErr: true,
},
@ -79,9 +126,12 @@ func TestSegmentDisplay(t *testing.T) {
},
{
desc: "draws multiple segments, all fit exactly",
opts: []Option{
GapPercent(0),
},
canvas: image.Rect(0, 0, sixteen.MinCols*3, sixteen.MinRows),
update: func(sd *SegmentDisplay) error {
return sd.Write(NewChunk("123"))
return sd.Write([]*TextChunk{NewChunk("123")})
},
want: func(size image.Point) *faketerm.Terminal {
ft := faketerm.MustNew(size)
@ -104,9 +154,12 @@ func TestSegmentDisplay(t *testing.T) {
},
{
desc: "write sanitizes text by default",
opts: []Option{
GapPercent(0),
},
canvas: image.Rect(0, 0, sixteen.MinCols*2, sixteen.MinRows),
update: func(sd *SegmentDisplay) error {
return sd.Write(NewChunk(".1"))
return sd.Write([]*TextChunk{NewChunk(".1")})
},
want: func(size image.Point) *faketerm.Terminal {
ft := faketerm.MustNew(size)
@ -120,9 +173,12 @@ func TestSegmentDisplay(t *testing.T) {
},
{
desc: "write sanitizes text with option",
opts: []Option{
GapPercent(0),
},
canvas: image.Rect(0, 0, sixteen.MinCols*2, sixteen.MinRows),
update: func(sd *SegmentDisplay) error {
return sd.Write(NewChunk(".1", WriteSanitize()))
return sd.Write([]*TextChunk{NewChunk(".1", WriteSanitize())})
},
want: func(size image.Point) *faketerm.Terminal {
ft := faketerm.MustNew(size)
@ -138,7 +194,7 @@ func TestSegmentDisplay(t *testing.T) {
desc: "aligns segment vertical middle by default",
canvas: image.Rect(0, 0, sixteen.MinCols, sixteen.MinRows+2),
update: func(sd *SegmentDisplay) error {
return sd.Write(NewChunk("1"))
return sd.Write([]*TextChunk{NewChunk("1")})
},
want: func(size image.Point) *faketerm.Terminal {
ft := faketerm.MustNew(size)
@ -154,10 +210,10 @@ func TestSegmentDisplay(t *testing.T) {
desc: "subsequent calls to write overwrite previous text",
canvas: image.Rect(0, 0, sixteen.MinCols, sixteen.MinRows+2),
update: func(sd *SegmentDisplay) error {
if err := sd.Write(NewChunk("123")); err != nil {
if err := sd.Write([]*TextChunk{NewChunk("123")}); err != nil {
return err
}
return sd.Write(NewChunk("4"))
return sd.Write([]*TextChunk{NewChunk("4")})
},
want: func(size image.Point) *faketerm.Terminal {
ft := faketerm.MustNew(size)
@ -171,9 +227,13 @@ func TestSegmentDisplay(t *testing.T) {
},
{
desc: "sets cell options per text chunk",
opts: []Option{
GapPercent(0),
},
canvas: image.Rect(0, 0, sixteen.MinCols*2, sixteen.MinRows),
update: func(sd *SegmentDisplay) error {
return sd.Write(
[]*TextChunk{
NewChunk("1", WriteCellOpts(
cell.FgColor(cell.ColorRed),
cell.BgColor(cell.ColorBlue),
@ -182,7 +242,7 @@ func TestSegmentDisplay(t *testing.T) {
cell.FgColor(cell.ColorGreen),
cell.BgColor(cell.ColorYellow),
)),
)
})
},
want: func(size image.Point) *faketerm.Terminal {
ft := faketerm.MustNew(size)
@ -213,7 +273,7 @@ func TestSegmentDisplay(t *testing.T) {
desc: "reset resets the text content",
canvas: image.Rect(0, 0, sixteen.MinCols, sixteen.MinRows+2),
update: func(sd *SegmentDisplay) error {
if err := sd.Write(NewChunk("123")); err != nil {
if err := sd.Write([]*TextChunk{NewChunk("123")}); err != nil {
return err
}
sd.Reset()
@ -225,15 +285,16 @@ func TestSegmentDisplay(t *testing.T) {
canvas: image.Rect(0, 0, sixteen.MinCols, sixteen.MinRows),
update: func(sd *SegmentDisplay) error {
if err := sd.Write(
[]*TextChunk{
NewChunk("1", WriteCellOpts(
cell.FgColor(cell.ColorRed),
cell.BgColor(cell.ColorBlue),
)),
); err != nil {
}); err != nil {
return err
}
sd.Reset()
return sd.Write(NewChunk("1"))
return sd.Write([]*TextChunk{NewChunk("1")})
},
want: func(size image.Point) *faketerm.Terminal {
ft := faketerm.MustNew(size)
@ -252,7 +313,7 @@ func TestSegmentDisplay(t *testing.T) {
},
canvas: image.Rect(0, 0, sixteen.MinCols, sixteen.MinRows+2),
update: func(sd *SegmentDisplay) error {
return sd.Write(NewChunk("1"))
return sd.Write([]*TextChunk{NewChunk("1")})
},
want: func(size image.Point) *faketerm.Terminal {
ft := faketerm.MustNew(size)
@ -271,7 +332,29 @@ func TestSegmentDisplay(t *testing.T) {
},
canvas: image.Rect(0, 0, sixteen.MinCols, sixteen.MinRows+2),
update: func(sd *SegmentDisplay) error {
return sd.Write(NewChunk("1"))
return sd.Write([]*TextChunk{NewChunk("1")})
},
want: func(size image.Point) *faketerm.Terminal {
ft := faketerm.MustNew(size)
cvs := testcanvas.MustNew(ft.Area())
mustDrawChar(cvs, '1', image.Rect(0, 0, sixteen.MinCols, sixteen.MinRows))
testcanvas.MustApply(cvs, ft)
return ft
},
},
{
desc: "options given to Write override those given to New so aligns top",
opts: []Option{
AlignVertical(align.VerticalBottom),
},
canvas: image.Rect(0, 0, sixteen.MinCols, sixteen.MinRows+2),
update: func(sd *SegmentDisplay) error {
return sd.Write(
[]*TextChunk{NewChunk("1")},
AlignVertical(align.VerticalTop),
)
},
want: func(size image.Point) *faketerm.Terminal {
ft := faketerm.MustNew(size)
@ -290,7 +373,7 @@ func TestSegmentDisplay(t *testing.T) {
},
canvas: image.Rect(0, 0, sixteen.MinCols, sixteen.MinRows+2),
update: func(sd *SegmentDisplay) error {
return sd.Write(NewChunk("1"))
return sd.Write([]*TextChunk{NewChunk("1")})
},
want: func(size image.Point) *faketerm.Terminal {
ft := faketerm.MustNew(size)
@ -306,7 +389,7 @@ func TestSegmentDisplay(t *testing.T) {
desc: "aligns segment horizontal center by default",
canvas: image.Rect(0, 0, sixteen.MinCols+2, sixteen.MinRows),
update: func(sd *SegmentDisplay) error {
return sd.Write(NewChunk("8"))
return sd.Write([]*TextChunk{NewChunk("8")})
},
want: func(size image.Point) *faketerm.Terminal {
ft := faketerm.MustNew(size)
@ -325,7 +408,7 @@ func TestSegmentDisplay(t *testing.T) {
},
canvas: image.Rect(0, 0, sixteen.MinCols+2, sixteen.MinRows),
update: func(sd *SegmentDisplay) error {
return sd.Write(NewChunk("8"))
return sd.Write([]*TextChunk{NewChunk("8")})
},
want: func(size image.Point) *faketerm.Terminal {
ft := faketerm.MustNew(size)
@ -344,7 +427,7 @@ func TestSegmentDisplay(t *testing.T) {
},
canvas: image.Rect(0, 0, sixteen.MinCols+2, sixteen.MinRows),
update: func(sd *SegmentDisplay) error {
return sd.Write(NewChunk("8"))
return sd.Write([]*TextChunk{NewChunk("8")})
},
want: func(size image.Point) *faketerm.Terminal {
ft := faketerm.MustNew(size)
@ -363,7 +446,7 @@ func TestSegmentDisplay(t *testing.T) {
},
canvas: image.Rect(0, 0, sixteen.MinCols+2, sixteen.MinRows),
update: func(sd *SegmentDisplay) error {
return sd.Write(NewChunk("8"))
return sd.Write([]*TextChunk{NewChunk("8")})
},
want: func(size image.Point) *faketerm.Terminal {
ft := faketerm.MustNew(size)
@ -379,10 +462,11 @@ func TestSegmentDisplay(t *testing.T) {
desc: "draws multiple segments, not enough space, maximizes segment height with option",
opts: []Option{
MaximizeSegmentHeight(),
GapPercent(0),
},
canvas: image.Rect(0, 0, sixteen.MinCols*2, sixteen.MinRows),
update: func(sd *SegmentDisplay) error {
return sd.Write(NewChunk("123"))
return sd.Write([]*TextChunk{NewChunk("123")})
},
want: func(size image.Point) *faketerm.Terminal {
ft := faketerm.MustNew(size)
@ -404,9 +488,12 @@ func TestSegmentDisplay(t *testing.T) {
},
{
desc: "draws multiple segments, not enough space, maximizes displayed text by default and fits all",
opts: []Option{
GapPercent(0),
},
canvas: image.Rect(0, 0, sixteen.MinCols*3, sixteen.MinRows*4),
update: func(sd *SegmentDisplay) error {
return sd.Write(NewChunk("123"))
return sd.Write([]*TextChunk{NewChunk("123")})
},
want: func(size image.Point) *faketerm.Terminal {
ft := faketerm.MustNew(size)
@ -429,9 +516,12 @@ func TestSegmentDisplay(t *testing.T) {
},
{
desc: "draws multiple segments, not enough space, maximizes displayed text but cannot fit all",
opts: []Option{
GapPercent(0),
},
canvas: image.Rect(0, 0, sixteen.MinCols*3, sixteen.MinRows*4),
update: func(sd *SegmentDisplay) error {
return sd.Write(NewChunk("1234"))
return sd.Write([]*TextChunk{NewChunk("1234")})
},
want: func(size image.Point) *faketerm.Terminal {
ft := faketerm.MustNew(size)
@ -456,10 +546,11 @@ func TestSegmentDisplay(t *testing.T) {
desc: "draws multiple segments, not enough space, maximizes displayed text with option",
opts: []Option{
MaximizeDisplayedText(),
GapPercent(0),
},
canvas: image.Rect(0, 0, sixteen.MinCols*3, sixteen.MinRows*4),
update: func(sd *SegmentDisplay) error {
return sd.Write(NewChunk("123"))
return sd.Write([]*TextChunk{NewChunk("123")})
},
want: func(size image.Point) *faketerm.Terminal {
ft := faketerm.MustNew(size)
@ -476,6 +567,170 @@ func TestSegmentDisplay(t *testing.T) {
mustDrawChar(cvs, tc.char, tc.area)
}
testcanvas.MustApply(cvs, ft)
return ft
},
},
{
desc: "draws multiple segments with a gap by default",
canvas: image.Rect(0, 0, sixteen.MinCols*3+2, sixteen.MinRows),
update: func(sd *SegmentDisplay) error {
return sd.Write([]*TextChunk{NewChunk("123")})
},
want: func(size image.Point) *faketerm.Terminal {
ft := faketerm.MustNew(size)
cvs := testcanvas.MustNew(ft.Area())
for _, tc := range []struct {
char rune
area image.Rectangle
}{
{'1', image.Rect(0, 0, sixteen.MinCols, sixteen.MinRows)},
{'2', image.Rect(sixteen.MinCols+1, 0, sixteen.MinCols*2+1, sixteen.MinRows)},
{'3', image.Rect(sixteen.MinCols*2+2, 0, sixteen.MinCols*3+2, sixteen.MinRows)},
} {
mustDrawChar(cvs, tc.char, tc.area)
}
testcanvas.MustApply(cvs, ft)
return ft
},
},
{
desc: "draws multiple segments with a gap, exact fit",
opts: []Option{
GapPercent(20),
},
canvas: image.Rect(0, 0, sixteen.MinCols*3+2, sixteen.MinRows),
update: func(sd *SegmentDisplay) error {
return sd.Write([]*TextChunk{NewChunk("123")})
},
want: func(size image.Point) *faketerm.Terminal {
ft := faketerm.MustNew(size)
cvs := testcanvas.MustNew(ft.Area())
for _, tc := range []struct {
char rune
area image.Rectangle
}{
{'1', image.Rect(0, 0, sixteen.MinCols, sixteen.MinRows)},
{'2', image.Rect(sixteen.MinCols+1, 0, sixteen.MinCols*2+1, sixteen.MinRows)},
{'3', image.Rect(sixteen.MinCols*2+2, 0, sixteen.MinCols*3+2, sixteen.MinRows)},
} {
mustDrawChar(cvs, tc.char, tc.area)
}
testcanvas.MustApply(cvs, ft)
return ft
},
},
{
desc: "draws multiple segments with a larger gap",
opts: []Option{
GapPercent(40),
},
canvas: image.Rect(0, 0, sixteen.MinCols*3+2, sixteen.MinRows),
update: func(sd *SegmentDisplay) error {
return sd.Write([]*TextChunk{NewChunk("123")})
},
want: func(size image.Point) *faketerm.Terminal {
ft := faketerm.MustNew(size)
cvs := testcanvas.MustNew(ft.Area())
for _, tc := range []struct {
char rune
area image.Rectangle
}{
{'1', image.Rect(3, 0, 9, 5)},
{'2', image.Rect(11, 0, 17, 5)},
} {
mustDrawChar(cvs, tc.char, tc.area)
}
testcanvas.MustApply(cvs, ft)
return ft
},
},
{
desc: "draws multiple segments with a gap, not all fit, maximizes displayed text",
opts: []Option{
GapPercent(20),
},
canvas: image.Rect(0, 0, sixteen.MinCols*3+2, sixteen.MinRows),
update: func(sd *SegmentDisplay) error {
return sd.Write([]*TextChunk{NewChunk("8888")})
},
want: func(size image.Point) *faketerm.Terminal {
ft := faketerm.MustNew(size)
cvs := testcanvas.MustNew(ft.Area())
for _, tc := range []struct {
char rune
area image.Rectangle
}{
{'8', image.Rect(0, 0, sixteen.MinCols, sixteen.MinRows)},
{'8', image.Rect(sixteen.MinCols+1, 0, sixteen.MinCols*2+1, sixteen.MinRows)},
{'8', image.Rect(sixteen.MinCols*2+2, 0, sixteen.MinCols*3+2, sixteen.MinRows)},
} {
mustDrawChar(cvs, tc.char, tc.area)
}
testcanvas.MustApply(cvs, ft)
return ft
},
},
{
desc: "draws multiple segments with a gap, not all fit, last segment would fit without a gap",
opts: []Option{
GapPercent(20),
},
canvas: image.Rect(0, 0, sixteen.MinCols*4+2, sixteen.MinRows),
update: func(sd *SegmentDisplay) error {
return sd.Write([]*TextChunk{NewChunk("8888")})
},
want: func(size image.Point) *faketerm.Terminal {
ft := faketerm.MustNew(size)
cvs := testcanvas.MustNew(ft.Area())
for _, tc := range []struct {
char rune
area image.Rectangle
}{
{'8', image.Rect(3, 0, 9, 5)},
{'8', image.Rect(10, 0, 16, 5)},
{'8', image.Rect(17, 0, 23, 5)},
} {
mustDrawChar(cvs, tc.char, tc.area)
}
testcanvas.MustApply(cvs, ft)
return ft
},
},
{
desc: "draws multiple segments with a gap, not enough space, maximizes segment height with option",
opts: []Option{
MaximizeSegmentHeight(),
GapPercent(20),
},
canvas: image.Rect(0, 0, sixteen.MinCols*5, sixteen.MinRows*2),
update: func(sd *SegmentDisplay) error {
return sd.Write([]*TextChunk{NewChunk("123")})
},
want: func(size image.Point) *faketerm.Terminal {
ft := faketerm.MustNew(size)
cvs := testcanvas.MustNew(ft.Area())
for _, tc := range []struct {
char rune
area image.Rectangle
}{
{'1', image.Rect(2, 0, 14, 10)},
{'2', image.Rect(16, 0, 28, 10)},
} {
mustDrawChar(cvs, tc.char, tc.area)
}
testcanvas.MustApply(cvs, ft)
return ft
},
@ -484,7 +739,14 @@ func TestSegmentDisplay(t *testing.T) {
for _, tc := range tests {
t.Run(tc.desc, func(t *testing.T) {
sd := New(tc.opts...)
sd, err := New(tc.opts...)
if (err != nil) != tc.wantNewErr {
t.Errorf("New => unexpected error: %v, wantNewErr: %v", err, tc.wantNewErr)
}
if err != nil {
return
}
c, err := canvas.New(tc.canvas)
if err != nil {
t.Fatalf("canvas.New => unexpected error: %v", err)
@ -494,7 +756,6 @@ func TestSegmentDisplay(t *testing.T) {
err = tc.update(sd)
if (err != nil) != tc.wantUpdateErr {
t.Errorf("update => unexpected error: %v, wantUpdateErr: %v", err, tc.wantUpdateErr)
}
if err != nil {
return
@ -533,21 +794,30 @@ func TestSegmentDisplay(t *testing.T) {
}
func TestKeyboard(t *testing.T) {
sd := New()
sd, err := New()
if err != nil {
t.Fatalf("New => unexpected error: %v", err)
}
if err := sd.Keyboard(&terminalapi.Keyboard{}); err == nil {
t.Errorf("Keyboard => got nil err, wanted one")
}
}
func TestMouse(t *testing.T) {
sd := New()
sd, err := New()
if err != nil {
t.Fatalf("New => unexpected error: %v", err)
}
if err := sd.Mouse(&terminalapi.Mouse{}); err == nil {
t.Errorf("Mouse => got nil err, wanted one")
}
}
func TestOptions(t *testing.T) {
sd := New()
sd, err := New()
if err != nil {
t.Fatalf("New => unexpected error: %v", err)
}
got := sd.Options()
want := widgetapi.Options{
MinimumSize: image.Point{sixteen.MinCols, sixteen.MinRows},

9
widgets/segmentdisplay/segmentdisplaydemo/segmentdisplaydemo.go
View File

@ -35,8 +35,8 @@ func clock(ctx context.Context, sd *segmentdisplay.SegmentDisplay) {
for {
select {
case <-ticker.C:
now := time.Now().Format("150405")
if err := sd.Write(segmentdisplay.NewChunk(now)); err != nil {
now := segmentdisplay.NewChunk(time.Now().Format("150405"))
if err := sd.Write([]*segmentdisplay.TextChunk{now}); err != nil {
panic(err)
}
@ -54,7 +54,10 @@ func main() {
defer t.Close()
ctx, cancel := context.WithCancel(context.Background())
sd := segmentdisplay.New()
sd, err := segmentdisplay.New()
if err != nil {
panic(err)
}
go clock(ctx, sd)
c, err := container.New(