org.jline.utils.AttributedStringBuilder Maven / Gradle / Ivy
The newest version!
/*
* Copyright (c) 2002-2018, the original author or authors.
*
* This software is distributable under the BSD license. See the terms of the
* BSD license in the documentation provided with this software.
*
* https://opensource.org/licenses/BSD-3-Clause
*/
package org.jline.utils;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
/**
* Attributed string builder
*
* @author Guillaume Nodet
*/
public class AttributedStringBuilder extends AttributedCharSequence implements Appendable {
private char[] buffer;
private int[] style;
private int length;
private TabStops tabs = new TabStops(0);
private int lastLineLength = 0;
private AttributedStyle current = AttributedStyle.DEFAULT;
public static AttributedString append(CharSequence... strings) {
AttributedStringBuilder sb = new AttributedStringBuilder();
for (CharSequence s : strings) {
sb.append(s);
}
return sb.toAttributedString();
}
public AttributedStringBuilder() {
this(64);
}
public AttributedStringBuilder(int capacity) {
buffer = new char[capacity];
style = new int[capacity];
length = 0;
}
@Override
public int length() {
return length;
}
@Override
public char charAt(int index) {
return buffer[index];
}
@Override
public AttributedStyle styleAt(int index) {
return new AttributedStyle(style[index], style[index]);
}
@Override
int styleCodeAt(int index) {
return style[index];
}
@Override
protected char[] buffer() {
return buffer;
}
@Override
protected int offset() {
return 0;
}
@Override
public AttributedString subSequence(int start, int end) {
return new AttributedString(
Arrays.copyOfRange(buffer, start, end),
Arrays.copyOfRange(style, start, end),
0,
end - start);
}
@Override
public AttributedStringBuilder append(CharSequence csq) {
if (csq == null) {
csq = "null"; // Required by Appendable.append
}
return append(new AttributedString(csq, current));
}
@Override
public AttributedStringBuilder append(CharSequence csq, int start, int end) {
if (csq == null) {
csq = "null"; // Required by Appendable.append
}
return append(csq.subSequence(start, end));
}
@Override
public AttributedStringBuilder append(char c) {
return append(Character.toString(c));
}
public AttributedStringBuilder append(CharSequence csq, AttributedStyle style) {
return append(new AttributedString(csq, style));
}
public AttributedStringBuilder style(AttributedStyle style) {
current = style;
return this;
}
public AttributedStringBuilder style(Function style) {
current = style.apply(current);
return this;
}
public AttributedStringBuilder styled(Function style, CharSequence cs) {
return styled(style, sb -> sb.append(cs));
}
public AttributedStringBuilder styled(AttributedStyle style, CharSequence cs) {
return styled(s -> style, sb -> sb.append(cs));
}
public AttributedStringBuilder styled(Function style, Consumer consumer) {
AttributedStyle prev = current;
current = style.apply(prev);
consumer.accept(this);
current = prev;
return this;
}
public AttributedStyle style() {
return current;
}
public AttributedStringBuilder append(AttributedString str) {
return append((AttributedCharSequence) str, 0, str.length());
}
public AttributedStringBuilder append(AttributedString str, int start, int end) {
return append((AttributedCharSequence) str, start, end);
}
public AttributedStringBuilder append(AttributedCharSequence str) {
return append(str, 0, str.length());
}
public AttributedStringBuilder append(AttributedCharSequence str, int start, int end) {
ensureCapacity(length + end - start);
for (int i = start; i < end; i++) {
char c = str.charAt(i);
int s = str.styleCodeAt(i) & ~current.getMask() | current.getStyle();
if (tabs.defined() && c == '\t') {
insertTab(new AttributedStyle(s, 0));
} else {
ensureCapacity(length + 1);
buffer[length] = c;
style[length] = s;
if (c == '\n') {
lastLineLength = 0;
} else {
lastLineLength++;
}
length++;
}
}
return this;
}
protected void ensureCapacity(int nl) {
if (nl > buffer.length) {
int s = Math.max(buffer.length, 1);
while (s <= nl) {
s *= 2;
}
buffer = Arrays.copyOf(buffer, s);
style = Arrays.copyOf(style, s);
}
}
public void appendAnsi(String ansi) {
ansiAppend(ansi);
}
public AttributedStringBuilder ansiAppend(String ansi) {
int ansiStart = 0;
int ansiState = 0;
ensureCapacity(length + ansi.length());
for (int i = 0; i < ansi.length(); i++) {
char c = ansi.charAt(i);
if (ansiState == 0 && c == 27) {
ansiState++;
} else if (ansiState == 1 && c == '[') {
ansiState++;
ansiStart = i + 1;
} else if (ansiState == 2) {
if (c == 'm') {
String[] params = ansi.substring(ansiStart, i).split(";");
int j = 0;
while (j < params.length) {
int ansiParam = params[j].isEmpty() ? 0 : Integer.parseInt(params[j]);
switch (ansiParam) {
case 0:
current = AttributedStyle.DEFAULT;
break;
case 1:
current = current.bold();
break;
case 2:
current = current.faint();
break;
case 3:
current = current.italic();
break;
case 4:
current = current.underline();
break;
case 5:
current = current.blink();
break;
case 7:
current = current.inverse();
break;
case 8:
current = current.conceal();
break;
case 9:
current = current.crossedOut();
break;
case 22:
current = current.boldOff().faintOff();
break;
case 23:
current = current.italicOff();
break;
case 24:
current = current.underlineOff();
break;
case 25:
current = current.blinkOff();
break;
case 27:
current = current.inverseOff();
break;
case 28:
current = current.concealOff();
break;
case 29:
current = current.crossedOutOff();
break;
case 30:
case 31:
case 32:
case 33:
case 34:
case 35:
case 36:
case 37:
current = current.foreground(ansiParam - 30);
break;
case 39:
current = current.foregroundOff();
break;
case 40:
case 41:
case 42:
case 43:
case 44:
case 45:
case 46:
case 47:
current = current.background(ansiParam - 40);
break;
case 49:
current = current.backgroundOff();
break;
case 38:
case 48:
if (j + 1 < params.length) {
int ansiParam2 = Integer.parseInt(params[++j]);
if (ansiParam2 == 2) {
if (j + 3 < params.length) {
int r = Integer.parseInt(params[++j]);
int g = Integer.parseInt(params[++j]);
int b = Integer.parseInt(params[++j]);
// convert to 256 colors
int col = 16 + (r >> 3) * 36 + (g >> 3) * 6 + (b >> 3);
if (ansiParam == 38) {
current = current.foreground(col);
} else {
current = current.background(col);
}
}
} else if (ansiParam2 == 5) {
if (j + 1 < params.length) {
int col = Integer.parseInt(params[++j]);
if (ansiParam == 38) {
current = current.foreground(col);
} else {
current = current.background(col);
}
}
}
}
break;
case 90:
case 91:
case 92:
case 93:
case 94:
case 95:
case 96:
case 97:
current = current.foreground(ansiParam - 90 + 8);
break;
case 100:
case 101:
case 102:
case 103:
case 104:
case 105:
case 106:
case 107:
current = current.background(ansiParam - 100 + 8);
break;
}
j++;
}
ansiState = 0;
} else if (!(c >= '0' && c <= '9' || c == ';')) {
// This is not a SGR code, so ignore
ansiState = 0;
}
} else if (c == '\t' && tabs.defined()) {
insertTab(current);
} else {
ensureCapacity(length + 1);
buffer[length] = c;
style[length] = this.current.getStyle();
if (c == '\n') {
lastLineLength = 0;
} else {
lastLineLength++;
}
length++;
}
}
return this;
}
protected void insertTab(AttributedStyle s) {
int nb = tabs.spaces(lastLineLength);
ensureCapacity(length + nb);
for (int i = 0; i < nb; i++) {
buffer[length] = ' ';
style[length] = s.getStyle();
length++;
}
lastLineLength += nb;
}
public void setLength(int l) {
length = l;
}
/**
* Set the number of spaces a tab is expanded to. Tab size cannot be changed
* after text has been added to prevent inconsistent indentation.
*
* If tab size is set to 0, tabs are not expanded (the default).
* @param tabsize Spaces per tab or 0 for no tab expansion. Must be non-negative
* @return this
*/
public AttributedStringBuilder tabs(int tabsize) {
if (tabsize < 0) {
throw new IllegalArgumentException("Tab size must be non negative");
}
return tabs(Arrays.asList(tabsize));
}
public AttributedStringBuilder tabs(List tabs) {
if (length > 0) {
throw new IllegalStateException("Cannot change tab size after appending text");
}
this.tabs = new TabStops(tabs);
return this;
}
public AttributedStringBuilder styleMatches(Pattern pattern, AttributedStyle s) {
Matcher matcher = pattern.matcher(this);
while (matcher.find()) {
for (int i = matcher.start(); i < matcher.end(); i++) {
style[i] = (style[i] & ~s.getMask()) | s.getStyle();
}
}
return this;
}
public AttributedStringBuilder styleMatches(Pattern pattern, List styles) {
Matcher matcher = pattern.matcher(this);
while (matcher.find()) {
for (int group = 0; group < matcher.groupCount(); group++) {
AttributedStyle s = styles.get(group);
for (int i = matcher.start(group + 1); i < matcher.end(group + 1); i++) {
style[i] = (style[i] & ~s.getMask()) | s.getStyle();
}
}
}
return this;
}
private class TabStops {
private List tabs = new ArrayList<>();
private int lastStop = 0;
private int lastSize = 0;
public TabStops(int tabs) {
this.lastSize = tabs;
}
public TabStops(List tabs) {
this.tabs = tabs;
int p = 0;
for (int s: tabs) {
if (s <= p) {
continue;
}
lastStop = s;
lastSize = s - p;
p = s;
}
}
boolean defined() {
return lastSize > 0;
}
int spaces(int lastLineLength) {
int out = 0;
if (lastLineLength >= lastStop) {
out = lastSize - (lastLineLength - lastStop) % lastSize;
} else {
for (int s: tabs) {
if (s > lastLineLength) {
out = s - lastLineLength;
break;
}
}
}
return out;
}
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy