mirror of
https://github.com/mrusme/neonmodem.git
synced 2024-09-01 04:14:15 -04:00
209 lines
4.1 KiB
Go
209 lines
4.1 KiB
Go
package helpers
|
|
|
|
import (
|
|
"bytes"
|
|
"strings"
|
|
|
|
"github.com/charmbracelet/lipgloss"
|
|
"github.com/mattn/go-runewidth"
|
|
"github.com/muesli/ansi"
|
|
"github.com/muesli/reflow/truncate"
|
|
"github.com/muesli/termenv"
|
|
)
|
|
|
|
// Most of this code is borrowed from
|
|
// https://github.com/charmbracelet/lipgloss/pull/102
|
|
// as well as the lipgloss library, with some modification for what I needed.
|
|
|
|
// Split a string into lines, additionally returning the size of the widest
|
|
// line.
|
|
func getLines(s string) (lines []string, widest int) {
|
|
lines = strings.Split(s, "\n")
|
|
|
|
for _, l := range lines {
|
|
w := ansi.PrintableRuneWidth(l)
|
|
if widest < w {
|
|
widest = w
|
|
}
|
|
}
|
|
|
|
return lines, widest
|
|
}
|
|
|
|
// PlaceOverlay places fg on top of bg.
|
|
func PlaceOverlay(
|
|
x, y int,
|
|
fg, bg string,
|
|
shadow bool, opts ...WhitespaceOption,
|
|
) string {
|
|
fgLines, fgWidth := getLines(fg)
|
|
bgLines, bgWidth := getLines(bg)
|
|
bgHeight := len(bgLines)
|
|
fgHeight := len(fgLines)
|
|
|
|
if shadow {
|
|
var shadowbg string = ""
|
|
shadowchar := lipgloss.NewStyle().
|
|
Foreground(lipgloss.Color("#333333")).
|
|
Render("░")
|
|
for i := 0; i <= fgHeight; i++ {
|
|
if i == 0 {
|
|
shadowbg += " " + strings.Repeat(" ", fgWidth) + "\n"
|
|
} else {
|
|
shadowbg += " " + strings.Repeat(shadowchar, fgWidth) + "\n"
|
|
}
|
|
}
|
|
|
|
fg = PlaceOverlay(0, 0, fg, shadowbg, false, opts...)
|
|
fgLines, fgWidth = getLines(fg)
|
|
fgHeight = len(fgLines)
|
|
}
|
|
|
|
if fgWidth >= bgWidth && fgHeight >= bgHeight {
|
|
// FIXME: return fg or bg?
|
|
return fg
|
|
}
|
|
// TODO: allow placement outside of the bg box?
|
|
x = clamp(x, 0, bgWidth-fgWidth)
|
|
y = clamp(y, 0, bgHeight-fgHeight)
|
|
|
|
ws := &whitespace{}
|
|
for _, opt := range opts {
|
|
opt(ws)
|
|
}
|
|
|
|
var b strings.Builder
|
|
for i, bgLine := range bgLines {
|
|
if i > 0 {
|
|
b.WriteByte('\n')
|
|
}
|
|
if i < y || i >= y+fgHeight {
|
|
b.WriteString(bgLine)
|
|
continue
|
|
}
|
|
|
|
pos := 0
|
|
if x > 0 {
|
|
left := truncate.String(bgLine, uint(x))
|
|
pos = ansi.PrintableRuneWidth(left)
|
|
b.WriteString(left)
|
|
if pos < x {
|
|
b.WriteString(ws.render(x - pos))
|
|
pos = x
|
|
}
|
|
}
|
|
|
|
fgLine := fgLines[i-y]
|
|
b.WriteString(fgLine)
|
|
pos += ansi.PrintableRuneWidth(fgLine)
|
|
|
|
right := cutLeft(bgLine, pos)
|
|
bgWidth := ansi.PrintableRuneWidth(bgLine)
|
|
rightWidth := ansi.PrintableRuneWidth(right)
|
|
if rightWidth <= bgWidth-pos {
|
|
b.WriteString(ws.render(bgWidth - rightWidth - pos))
|
|
}
|
|
|
|
b.WriteString(right)
|
|
}
|
|
|
|
return b.String()
|
|
}
|
|
|
|
// cutLeft cuts printable characters from the left.
|
|
// This function is heavily based on muesli's ansi and truncate packages.
|
|
func cutLeft(s string, cutWidth int) string {
|
|
var (
|
|
pos int
|
|
isAnsi bool
|
|
ab bytes.Buffer
|
|
b bytes.Buffer
|
|
)
|
|
for _, c := range s {
|
|
var w int
|
|
if c == ansi.Marker || isAnsi {
|
|
isAnsi = true
|
|
ab.WriteRune(c)
|
|
if ansi.IsTerminator(c) {
|
|
isAnsi = false
|
|
if bytes.HasSuffix(ab.Bytes(), []byte("[0m")) {
|
|
ab.Reset()
|
|
}
|
|
}
|
|
} else {
|
|
w = runewidth.RuneWidth(c)
|
|
}
|
|
|
|
if pos >= cutWidth {
|
|
if b.Len() == 0 {
|
|
if ab.Len() > 0 {
|
|
b.Write(ab.Bytes())
|
|
}
|
|
if pos-cutWidth > 1 {
|
|
b.WriteByte(' ')
|
|
continue
|
|
}
|
|
}
|
|
b.WriteRune(c)
|
|
}
|
|
pos += w
|
|
}
|
|
return b.String()
|
|
}
|
|
|
|
func clamp(v, lower, upper int) int {
|
|
return min(max(v, lower), upper)
|
|
}
|
|
|
|
func max(a, b int) int {
|
|
if a > b {
|
|
return a
|
|
}
|
|
return b
|
|
}
|
|
|
|
func min(a, b int) int {
|
|
if a < b {
|
|
return a
|
|
}
|
|
return b
|
|
}
|
|
|
|
type whitespace struct {
|
|
style termenv.Style
|
|
chars string
|
|
}
|
|
|
|
// Render whitespaces.
|
|
func (w whitespace) render(width int) string {
|
|
if w.chars == "" {
|
|
w.chars = " "
|
|
}
|
|
|
|
r := []rune(w.chars)
|
|
j := 0
|
|
b := strings.Builder{}
|
|
|
|
// Cycle through runes and print them into the whitespace.
|
|
for i := 0; i < width; {
|
|
b.WriteRune(r[j])
|
|
j++
|
|
if j >= len(r) {
|
|
j = 0
|
|
}
|
|
i += ansi.PrintableRuneWidth(string(r[j]))
|
|
}
|
|
|
|
// Fill any extra gaps white spaces. This might be necessary if any runes
|
|
// are more than one cell wide, which could leave a one-rune gap.
|
|
short := width - ansi.PrintableRuneWidth(b.String())
|
|
if short > 0 {
|
|
b.WriteString(strings.Repeat(" ", short))
|
|
}
|
|
|
|
return w.style.Styled(b.String())
|
|
}
|
|
|
|
// WhitespaceOption sets a styling rule for rendering whitespace.
|
|
type WhitespaceOption func(*whitespace)
|