mirror of
https://github.com/KAMKEEL/CustomNPC-Plus.git
synced 2026-11-18 16:09:05 +00:00
Fixed various formatting line wrap bugs
This commit is contained in:
1 parent
28b8cda4cf
commit
57128a8d8b
4 files changed
+350
-30
No files matched your search
@@ -2088,7 +2088,9 @@ public class GuiScriptTextArea extends GuiNpcTextField {
|
||||
if (closeLineIdx < this.container.lines.size()) {
|
||||
int closeIndent = IndentHelper.getLineIndent(
|
||||
this.container.lines.get(closeLineIdx).text);
|
||||
if (closeIndent == indent.length()) {
|
||||
// <= handles multi-line declarations where '{' sits on a
|
||||
// continuation line with higher indent than the closing '}'
|
||||
if (closeIndent <= indent.length()) {
|
||||
hasMatchingClose = true;
|
||||
}
|
||||
}
|
||||
@@ -2940,9 +2942,11 @@ public class GuiScriptTextArea extends GuiNpcTextField {
|
||||
}
|
||||
|
||||
private void formatText() {
|
||||
// Calculate viewport width for line wrapping (account for gutter and scrollbar)
|
||||
int viewportWidth = this.width - LINE_NUMBER_GUTTER_WIDTH - 10;
|
||||
IndentHelper.FormatResult result = IndentHelper.formatText(text, selection.getCursorPosition(), viewportWidth);
|
||||
int viewportPixels = this.width - LINE_NUMBER_GUTTER_WIDTH - 10;
|
||||
int avgCharWidth = Math.max(1, ClientProxy.Font.width("abcdefghijklmnopqrstuvwxyz") / 26);
|
||||
int viewportChars = (int) (viewportPixels * 0.8f / avgCharWidth);
|
||||
int maxLineLength = Math.max(60, Math.min(viewportChars, 120));
|
||||
IndentHelper.FormatResult result = IndentHelper.formatText(text, selection.getCursorPosition(), maxLineLength);
|
||||
setText(result.text);
|
||||
selection.reset(Math.max(0, Math.min(result.cursorPosition, this.text.length())));
|
||||
}
|
||||
|
||||
@@ -326,7 +326,8 @@ public class BracketMatcher {
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a brace at given position has a matching close with same indent
|
||||
* Check if a brace at given position has a matching close with compatible indent.
|
||||
* Uses <= to handle multi-line declarations where '{' is on a continuation line.
|
||||
*/
|
||||
public static boolean hasMatchingCloseWithSameIndent(String text, int bracePos, List<LineData> lines, int currentIndent) {
|
||||
if (text == null || lines == null || bracePos < 0) return false;
|
||||
@@ -350,7 +351,7 @@ public class BracketMatcher {
|
||||
if (closeLineIdx < lines.size()) {
|
||||
String closeLine = lines.get(closeLineIdx).text;
|
||||
int closeIndent = getLineIndent(closeLine);
|
||||
return closeIndent == currentIndent;
|
||||
return closeIndent <= currentIndent;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1642,7 +1642,10 @@ public class FormatHelper {
|
||||
if (text == null || text.isEmpty()) return text;
|
||||
|
||||
int width = maxWidth > 0 ? maxWidth : settings.maxLineLength;
|
||||
String[] lines = text.split("\n", -1);
|
||||
|
||||
String joined = format(joinContinuationLines(text));
|
||||
|
||||
String[] lines = joined.split("\n", -1);
|
||||
StringBuilder result = new StringBuilder();
|
||||
|
||||
for (int i = 0; i < lines.length; i++) {
|
||||
@@ -1670,6 +1673,92 @@ public class FormatHelper {
|
||||
return result.toString();
|
||||
}
|
||||
|
||||
/**
|
||||
* Join continuation lines back onto their parent line so they can be
|
||||
* re-evaluated and re-wrapped at the current target width.
|
||||
* <p>
|
||||
* A "continuation line" is one whose trimmed content starts with an operator,
|
||||
* dot, comma, {@code ?}, or {@code :} — i.e. the wrapping markers used by
|
||||
* {@link #wrapCodeContent}. Only code continuation lines are joined; comment
|
||||
* lines ({@code //}, {@code *}) and lines inside lambda/block bodies (deeper
|
||||
* indent than expected) are left alone.
|
||||
*/
|
||||
private String joinContinuationLines(String text) {
|
||||
String[] lines = text.split("\n", -1);
|
||||
List<String> out = new ArrayList<>();
|
||||
|
||||
for (int i = 0; i < lines.length; i++) {
|
||||
String line = lines[i];
|
||||
String trimmed = line.trim();
|
||||
|
||||
if (trimmed.isEmpty()
|
||||
|| trimmed.startsWith("//")
|
||||
|| trimmed.startsWith("/*")
|
||||
|| trimmed.startsWith("*")) {
|
||||
out.add(line);
|
||||
continue;
|
||||
}
|
||||
|
||||
boolean shouldJoin = false;
|
||||
int parentIdx = -1;
|
||||
|
||||
if ((isContinuationLine(trimmed) || startsWithDeclarationKeyword(trimmed))
|
||||
&& !out.isEmpty()) {
|
||||
int idx = out.size() - 1;
|
||||
while (idx >= 0 && out.get(idx).trim().isEmpty()) idx--;
|
||||
if (idx >= 0) {
|
||||
String parentTrimmed = out.get(idx).trim();
|
||||
char last = parentTrimmed.isEmpty() ? 0 : parentTrimmed.charAt(parentTrimmed.length() - 1);
|
||||
if (last != '{' && last != '}' && last != ';') {
|
||||
shouldJoin = true;
|
||||
parentIdx = idx;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (!shouldJoin && !out.isEmpty()) {
|
||||
int idx = out.size() - 1;
|
||||
while (idx >= 0 && out.get(idx).trim().isEmpty()) idx--;
|
||||
if (idx >= 0) {
|
||||
String parentTrimmed = out.get(idx).trim();
|
||||
if (!parentTrimmed.isEmpty()) {
|
||||
char last = parentTrimmed.charAt(parentTrimmed.length() - 1);
|
||||
if (last == '&' || last == '|' || last == '<' || last == '+'
|
||||
|| last == '-' || last == '?' || last == ',' || last == '>') {
|
||||
shouldJoin = true;
|
||||
parentIdx = idx;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (shouldJoin) {
|
||||
out.set(parentIdx, trimTrailing(out.get(parentIdx)) + " " + trimmed);
|
||||
continue;
|
||||
}
|
||||
|
||||
out.add(line);
|
||||
}
|
||||
|
||||
StringBuilder sb = new StringBuilder();
|
||||
for (int i = 0; i < out.size(); i++) {
|
||||
sb.append(out.get(i));
|
||||
if (i < out.size() - 1) sb.append("\n");
|
||||
}
|
||||
return sb.toString();
|
||||
}
|
||||
|
||||
private boolean startsWithDeclarationKeyword(String trimmed) {
|
||||
for (String kw : DECLARATION_BREAK_KEYWORDS) {
|
||||
if (trimmed.startsWith(kw)
|
||||
&& (trimmed.length() == kw.length()
|
||||
|| !Character.isJavaIdentifierPart(trimmed.charAt(kw.length())))) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get visual length of a line (tabs count as 4 spaces).
|
||||
*/
|
||||
@@ -1987,6 +2076,13 @@ public class FormatHelper {
|
||||
* Core code wrapping logic (extracted from old wrapCodeLine, operates on code without comments).
|
||||
*/
|
||||
private String wrapCodeContent(String content, String indent, int maxWidth) {
|
||||
if (settings.wrapMethodArguments) {
|
||||
String argWrapped = tryArgumentAwareWrap(content, indent, maxWidth);
|
||||
if (argWrapped != null) {
|
||||
return argWrapped;
|
||||
}
|
||||
}
|
||||
|
||||
String wrapIndent = indent + spaces(settings.wrapIndentSpaces);
|
||||
String fullLine = indent + content;
|
||||
|
||||
@@ -2005,36 +2101,28 @@ public class FormatHelper {
|
||||
|
||||
int currentLen = getVisualLength(indent);
|
||||
int lastBreak = 0;
|
||||
boolean isFirstLine = true;
|
||||
|
||||
for (BreakPoint bp : breakPoints) {
|
||||
int segmentEnd = bp.position;
|
||||
String segment = content.substring(lastBreak, segmentEnd);
|
||||
int segmentLen = getVisualLength(segment);
|
||||
|
||||
if (currentLen + segmentLen > maxWidth && !isFirstLine) {
|
||||
if (currentLen + segmentLen > maxWidth && lastBreak > 0) {
|
||||
result.append("\n").append(wrapIndent);
|
||||
currentLen = getVisualLength(wrapIndent);
|
||||
isFirstLine = false;
|
||||
|
||||
segment = trimLeading(segment);
|
||||
} else if (currentLen + segmentLen > maxWidth && isFirstLine && lastBreak > 0) {
|
||||
result.append("\n").append(wrapIndent);
|
||||
currentLen = getVisualLength(wrapIndent);
|
||||
isFirstLine = false;
|
||||
}
|
||||
|
||||
result.append(segment);
|
||||
currentLen += getVisualLength(segment);
|
||||
lastBreak = segmentEnd;
|
||||
isFirstLine = false;
|
||||
}
|
||||
|
||||
if (lastBreak < content.length()) {
|
||||
String remaining = content.substring(lastBreak);
|
||||
int remLen = getVisualLength(remaining);
|
||||
|
||||
if (currentLen + remLen > maxWidth && !isFirstLine) {
|
||||
if (currentLen + remLen > maxWidth && lastBreak > 0) {
|
||||
result.append("\n").append(wrapIndent);
|
||||
remaining = trimLeading(remaining);
|
||||
}
|
||||
@@ -2046,8 +2134,188 @@ public class FormatHelper {
|
||||
}
|
||||
|
||||
/**
|
||||
* Trim leading whitespace (Java 8 compatible).
|
||||
* Try argument-aware wrapping for method/constructor calls.
|
||||
* When a call like {@code new Foo(arg1, arg2, arg3)} exceeds maxWidth,
|
||||
* break after the opening paren, put each argument on its own line,
|
||||
* and close paren on its own line:
|
||||
* <pre>
|
||||
* new Foo(
|
||||
* arg1,
|
||||
* arg2,
|
||||
* arg3
|
||||
* )
|
||||
* </pre>
|
||||
*
|
||||
* @return the wrapped string, or {@code null} if this content doesn't
|
||||
* qualify for argument-aware wrapping
|
||||
*/
|
||||
private String tryArgumentAwareWrap(String content, String indent, int maxWidth) {
|
||||
String fullLine = indent + content;
|
||||
if (getVisualLength(fullLine) <= maxWidth) {
|
||||
return null;
|
||||
}
|
||||
|
||||
int callParenIdx = findOutermostCallParen(content);
|
||||
if (callParenIdx < 0) {
|
||||
return null;
|
||||
}
|
||||
|
||||
int matchingClose = findMatchingClose(content, callParenIdx);
|
||||
if (matchingClose < 0 || matchingClose >= content.length()) {
|
||||
return null;
|
||||
}
|
||||
|
||||
String prefix = content.substring(0, callParenIdx + 1);
|
||||
String argsBody = content.substring(callParenIdx + 1, matchingClose);
|
||||
String suffix = content.substring(matchingClose);
|
||||
|
||||
List<String> args = splitArguments(argsBody);
|
||||
if (args.size() < 2) {
|
||||
return null;
|
||||
}
|
||||
|
||||
String argIndent = indent + spaces(settings.wrapIndentSpaces);
|
||||
String closeIndent = indent;
|
||||
|
||||
StringBuilder result = new StringBuilder();
|
||||
result.append(indent).append(prefix).append("\n");
|
||||
|
||||
for (int i = 0; i < args.size(); i++) {
|
||||
String arg = args.get(i).trim();
|
||||
if (arg.isEmpty()) continue;
|
||||
|
||||
result.append(argIndent).append(arg);
|
||||
if (i < args.size() - 1) {
|
||||
result.append(",");
|
||||
}
|
||||
result.append("\n");
|
||||
}
|
||||
|
||||
result.append(closeIndent).append(suffix);
|
||||
|
||||
String wrapped = result.toString();
|
||||
if (getVisualLength(indent + prefix) <= maxWidth) {
|
||||
return wrapped;
|
||||
}
|
||||
|
||||
return wrapped;
|
||||
}
|
||||
|
||||
/**
|
||||
* Find the opening paren of the outermost method/constructor call
|
||||
* that should trigger argument-aware wrapping.
|
||||
* Looks for patterns: {@code identifier(}, {@code new Type(}, {@code .method(}
|
||||
*
|
||||
* @return index of the '(' or -1 if no suitable call found
|
||||
*/
|
||||
private int findOutermostCallParen(String content) {
|
||||
int bestIdx = -1;
|
||||
boolean inString = false;
|
||||
char stringChar = 0;
|
||||
|
||||
for (int i = 0; i < content.length(); i++) {
|
||||
char c = content.charAt(i);
|
||||
char prev = i > 0 ? content.charAt(i - 1) : ' ';
|
||||
|
||||
if ((c == '"' || c == '\'') && prev != '\\') {
|
||||
if (!inString) {
|
||||
inString = true;
|
||||
stringChar = c;
|
||||
} else if (c == stringChar) {
|
||||
inString = false;
|
||||
}
|
||||
}
|
||||
if (inString) continue;
|
||||
|
||||
if (c == '(') {
|
||||
if (i > 0 && (Character.isJavaIdentifierPart(content.charAt(i - 1)) ||
|
||||
content.charAt(i - 1) == '>')) {
|
||||
bestIdx = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return bestIdx;
|
||||
}
|
||||
|
||||
private int findMatchingClose(String content, int openIdx) {
|
||||
int depth = 1;
|
||||
boolean inString = false;
|
||||
char stringChar = 0;
|
||||
|
||||
for (int i = openIdx + 1; i < content.length(); i++) {
|
||||
char c = content.charAt(i);
|
||||
char prev = i > 0 ? content.charAt(i - 1) : ' ';
|
||||
|
||||
if ((c == '"' || c == '\'') && prev != '\\') {
|
||||
if (!inString) {
|
||||
inString = true;
|
||||
stringChar = c;
|
||||
} else if (c == stringChar) {
|
||||
inString = false;
|
||||
}
|
||||
}
|
||||
if (inString) continue;
|
||||
|
||||
if (c == '(') depth++;
|
||||
else if (c == ')') {
|
||||
depth--;
|
||||
if (depth == 0) return i;
|
||||
}
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
/**
|
||||
* Split argument body by top-level commas, preserving nested parens,
|
||||
* brackets, braces, strings, and lambda bodies.
|
||||
*/
|
||||
private List<String> splitArguments(String argsBody) {
|
||||
List<String> args = new ArrayList<>();
|
||||
StringBuilder current = new StringBuilder();
|
||||
int depth = 0;
|
||||
boolean inString = false;
|
||||
char stringChar = 0;
|
||||
|
||||
for (int i = 0; i < argsBody.length(); i++) {
|
||||
char c = argsBody.charAt(i);
|
||||
char prev = i > 0 ? argsBody.charAt(i - 1) : ' ';
|
||||
|
||||
if ((c == '"' || c == '\'') && prev != '\\') {
|
||||
if (!inString) {
|
||||
inString = true;
|
||||
stringChar = c;
|
||||
} else if (c == stringChar) {
|
||||
inString = false;
|
||||
}
|
||||
}
|
||||
|
||||
if (inString) {
|
||||
current.append(c);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (c == '(' || c == '[' || c == '{') depth++;
|
||||
else if (c == ')' || c == ']' || c == '}') depth--;
|
||||
|
||||
if (c == ',' && depth == 0) {
|
||||
args.add(current.toString());
|
||||
current = new StringBuilder();
|
||||
continue;
|
||||
}
|
||||
|
||||
current.append(c);
|
||||
}
|
||||
|
||||
if (current.length() > 0) {
|
||||
args.add(current.toString());
|
||||
}
|
||||
|
||||
return args;
|
||||
}
|
||||
|
||||
private String trimLeading(String s) {
|
||||
int start = 0;
|
||||
while (start < s.length() && Character.isWhitespace(s.charAt(start))) {
|
||||
@@ -2070,6 +2338,10 @@ public class FormatHelper {
|
||||
}
|
||||
}
|
||||
|
||||
private static final String[] DECLARATION_BREAK_KEYWORDS = {
|
||||
"extends", "implements", "throws", "permits"
|
||||
};
|
||||
|
||||
/**
|
||||
* Find good positions to break a line.
|
||||
*/
|
||||
@@ -2125,15 +2397,41 @@ public class FormatHelper {
|
||||
if ((c == '+' || c == '-') && i > 0 && i < content.length() - 1) {
|
||||
char next = content.charAt(i + 1);
|
||||
if (prev != '(' && prev != '[' && prev != ',' && prev != '=' &&
|
||||
next != '+' && next != '-' && next != '=') {
|
||||
next != '+' && next != '-' && next != '=' && next != '>') {
|
||||
points.add(new BreakPoint(i + 1, 3 + depth));
|
||||
}
|
||||
}
|
||||
if (c == '&' && i + 1 < content.length() && content.charAt(i + 1) == '&') {
|
||||
points.add(new BreakPoint(i + 2, 2 + depth));
|
||||
i++; // skip second &
|
||||
continue;
|
||||
}
|
||||
if (c == '|' && i + 1 < content.length() && content.charAt(i + 1) == '|') {
|
||||
points.add(new BreakPoint(i + 2, 2 + depth));
|
||||
i++; // skip second |
|
||||
continue;
|
||||
}
|
||||
// Single & as type intersection operator (e.g. T extends A & B)
|
||||
if (c == '&' && i > 0 && i < content.length() - 1
|
||||
&& content.charAt(i + 1) != '&' && content.charAt(i + 1) != '=') {
|
||||
points.add(new BreakPoint(i + 1, 3 + depth));
|
||||
}
|
||||
if (c == '?' && depth == 0 && i > 0 && i < content.length() - 1) {
|
||||
points.add(new BreakPoint(i, 2));
|
||||
}
|
||||
if (c == ':' && depth == 0 && i > 0 && i < content.length() - 1) {
|
||||
if (prev != ':' && (i + 1 >= content.length() || content.charAt(i + 1) != ':')) {
|
||||
points.add(new BreakPoint(i, 2));
|
||||
}
|
||||
}
|
||||
if (c == '=' && depth == 0 && i > 0 && i < content.length() - 1) {
|
||||
char next = content.charAt(i + 1);
|
||||
if (prev != '=' && prev != '!' && prev != '<' && prev != '>' &&
|
||||
prev != '+' && prev != '-' && prev != '*' && prev != '/' &&
|
||||
prev != '%' && prev != '&' && prev != '|' && prev != '^' &&
|
||||
next != '=' && next != '>') {
|
||||
points.add(new BreakPoint(i + 1, 4 + depth));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2142,9 +2440,28 @@ public class FormatHelper {
|
||||
points.add(new BreakPoint(i, 2 + depth));
|
||||
}
|
||||
|
||||
// After opening brace
|
||||
if (c == '{' && i + 1 < content.length()) {
|
||||
points.add(new BreakPoint(i + 1, 1));
|
||||
// After opening brace (even when last char — allows break before {)
|
||||
if (c == '{') {
|
||||
if (i + 1 < content.length()) {
|
||||
points.add(new BreakPoint(i + 1, 1));
|
||||
}
|
||||
// Break before { so the brace can move to its own line
|
||||
if (i > 0) {
|
||||
points.add(new BreakPoint(i, 2));
|
||||
}
|
||||
}
|
||||
|
||||
// Break before declaration keywords (extends, implements, throws, permits)
|
||||
if (c == ' ' && i + 1 < content.length() && Character.isLetter(content.charAt(i + 1))) {
|
||||
for (String kw : DECLARATION_BREAK_KEYWORDS) {
|
||||
if (i + 1 + kw.length() <= content.length()
|
||||
&& content.substring(i + 1, i + 1 + kw.length()).equals(kw)
|
||||
&& (i + 1 + kw.length() >= content.length()
|
||||
|| !Character.isJavaIdentifierPart(content.charAt(i + 1 + kw.length())))) {
|
||||
points.add(new BreakPoint(i + 1, 2));
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -157,9 +157,9 @@ public class IndentHelper {
|
||||
*
|
||||
* @param text The text to format
|
||||
* @param cursorPosition Current cursor position
|
||||
* @param viewportWidth Viewport width for line wrapping (0 = no wrapping)
|
||||
* @param maxLineLength Maximum line length in characters for wrapping (0 = no wrapping)
|
||||
*/
|
||||
public static FormatResult formatText(String text, int cursorPosition, int viewportWidth) {
|
||||
public static FormatResult formatText(String text, int cursorPosition, int maxLineLength) {
|
||||
// First pass: fix indentation
|
||||
String indented = formatIndentation(text, cursorPosition);
|
||||
|
||||
@@ -167,19 +167,17 @@ public class IndentHelper {
|
||||
FormatHelper helper = new FormatHelper();
|
||||
FormatHelper.FormatSettings settings = helper.getSettings();
|
||||
|
||||
// Enable wrapping if viewport width is provided
|
||||
if (viewportWidth > 0) {
|
||||
// Enable wrapping if max line length is provided
|
||||
if (maxLineLength > 0) {
|
||||
settings.wrapLongLines = true;
|
||||
settings.wrapComments = true;
|
||||
// Use 75% of viewport width as max line length for some margin
|
||||
int charWidth = 6; // Approximate character width
|
||||
settings.maxLineLength = Math.max(60, (int) (viewportWidth * 0.8f / charWidth));
|
||||
settings.maxLineLength = maxLineLength;
|
||||
}
|
||||
|
||||
String formatted = helper.format(indented);
|
||||
|
||||
// Apply wrapping if enabled
|
||||
if (viewportWidth > 0 && settings.wrapLongLines) {
|
||||
if (maxLineLength > 0 && settings.wrapLongLines) {
|
||||
formatted = helper.wrapLines(formatted, settings.maxLineLength);
|
||||
}
|
||||
|
||||
|
||||
Reference in new issue
Block a user