mirror of
https://github.com/KAMKEEL/CustomNPC-Plus.git
synced 2026-11-18 18:29:05 +00:00
Refactore/Rename KeyPrest + functionality
This commit is contained in:
1 parent
6f0ccace42
commit
e75e87dd43
3 files changed
+1063
-3
No files matched your search
@@ -92,6 +92,9 @@ public class GuiScriptTextArea extends GuiNpcTextField {
|
||||
// ==================== GO TO LINE ====================
|
||||
private final GoToLineDialog goToLineDialog;
|
||||
|
||||
// ==================== RENAME REFACTOR ====================
|
||||
private final RenameRefactorHandler renameHandler = new RenameRefactorHandler();
|
||||
|
||||
// ==================== CONSTRUCTOR ====================
|
||||
|
||||
public GuiScriptTextArea(GuiScreen guiScreen, int id, int x, int y, int width, int height, String text) {
|
||||
@@ -254,6 +257,113 @@ public class GuiScriptTextArea extends GuiNpcTextField {
|
||||
selection.markActivity();
|
||||
}
|
||||
});
|
||||
|
||||
// Initialize Rename Refactor handler with callback
|
||||
renameHandler.setCallback(new RenameRefactorHandler.RenameCallback() {
|
||||
@Override
|
||||
public String getText() {
|
||||
return GuiScriptTextArea.this.text;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setText(String newText) {
|
||||
GuiScriptTextArea.this.setText(newText);
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<LineData> getLines() {
|
||||
return container != null ? container.lines : new ArrayList<>();
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getCursorPosition() {
|
||||
return selection.getCursorPosition();
|
||||
}
|
||||
|
||||
public SelectionState getSelectionState() {
|
||||
return selection;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setCursorPosition(int pos) {
|
||||
selection.reset(pos);
|
||||
}
|
||||
|
||||
@Override
|
||||
public void unfocusMainEditor() {
|
||||
active = false;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void focusMainEditor() {
|
||||
active = true;
|
||||
selection.markActivity();
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getGutterWidth() {
|
||||
return LINE_NUMBER_GUTTER_WIDTH;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getLineHeight() {
|
||||
return container != null ? container.lineHeight : 12;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getScrolledLine() {
|
||||
return scroll.getScrolledLine();
|
||||
}
|
||||
|
||||
@Override
|
||||
public double getFractionalOffset() {
|
||||
return scroll.getFractionalOffset();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void scrollToPosition(int pos) {
|
||||
if (container == null || container.lines == null)
|
||||
return;
|
||||
for (int i = 0; i < container.lines.size(); i++) {
|
||||
LineData ld = container.lines.get(i);
|
||||
if (pos >= ld.start && pos < ld.end) {
|
||||
int visible = Math.max(1, container.visibleLines);
|
||||
int effectiveVisible = Math.max(1, visible - bottomPaddingLines);
|
||||
int maxScroll = Math.max(0, getPaddedLineCount() - visible);
|
||||
scroll.scrollToLine(i, effectiveVisible, maxScroll);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public JavaTextContainer getContainer() {
|
||||
return container;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setTextWithoutUndo(String newText) {
|
||||
// Set text without creating an undo entry (for live rename preview)
|
||||
boolean wasUndoing = undoing;
|
||||
undoing = true;
|
||||
setText(newText);
|
||||
undoing = wasUndoing;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void pushUndoState(String textState) {
|
||||
// Push a specific text state to the undo list
|
||||
if (!undoing) {
|
||||
undoList.add(new UndoData(textState, selection.getCursorPosition()));
|
||||
redoList.clear();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getViewportWidth() {
|
||||
return width - LINE_NUMBER_GUTTER_WIDTH - 8; // Account for gutter and scrollbar
|
||||
}
|
||||
});
|
||||
|
||||
initializeKeyBindings();
|
||||
init(x, y, width, height, text);
|
||||
@@ -536,6 +646,56 @@ public class GuiScriptTextArea extends GuiNpcTextField {
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Highlight rename refactor occurrences
|
||||
if (renameHandler.isActive()) {
|
||||
List<int[]> renameOccurrences = renameHandler.getOccurrences();
|
||||
for (int[] occ : renameOccurrences) {
|
||||
// Check if occurrence overlaps with this line
|
||||
if (occ[1] > data.start && occ[0] < data.end) {
|
||||
int occStart = Math.max(occ[0] - data.start, 0);
|
||||
int occEnd = Math.min(occ[1] - data.start, line.length());
|
||||
if (occStart < occEnd) {
|
||||
int s = ClientProxy.Font.width(line.substring(0, occStart));
|
||||
int e = ClientProxy.Font.width(line.substring(0, occEnd)) + 1;
|
||||
int occX = x + LINE_NUMBER_GUTTER_WIDTH + 1 + s;
|
||||
int occEndX = x + LINE_NUMBER_GUTTER_WIDTH + 1 + e;
|
||||
boolean isPrimary = renameHandler.isPrimaryOccurrence(occ[0]);
|
||||
|
||||
// Draw background highlight
|
||||
int bgColor = isPrimary ? 0x55335577 : 0x33224466;
|
||||
drawRect(occX, posY, occEndX, posY + container.lineHeight, bgColor);
|
||||
|
||||
// Draw white border for primary occurrence (IntelliJ-like)
|
||||
if (isPrimary) {
|
||||
int borderColor = 0xDDFFFFFF;
|
||||
// Top border
|
||||
drawRect(occX, posY, occEndX, posY + 1, borderColor);
|
||||
// Bottom border
|
||||
drawRect(occX, posY + container.lineHeight - 1, occEndX,
|
||||
posY + container.lineHeight, borderColor);
|
||||
// Left border
|
||||
drawRect(occX, posY, occX + 1, posY + container.lineHeight, borderColor);
|
||||
// Right border
|
||||
drawRect(occEndX - 1, posY, occEndX, posY + container.lineHeight, borderColor);
|
||||
|
||||
// Draw cursor inside the primary occurrence
|
||||
if (renameHandler.shouldShowCursor()) {
|
||||
int cursorInWord = renameHandler.getCursorInWord();
|
||||
String currentWord = renameHandler.getCurrentWord();
|
||||
if (currentWord != null && cursorInWord >= 0 && cursorInWord <= currentWord.length()) {
|
||||
String beforeCursor = currentWord.substring(0,
|
||||
Math.min(cursorInWord, currentWord.length()));
|
||||
int cursorX = occX + ClientProxy.Font.width(beforeCursor);
|
||||
drawRect(cursorX, posY + 1, cursorX + 1, posY + container.lineHeight - 1,
|
||||
0xFFFFFFFF);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Highlight the current line (light gray) under any selection
|
||||
if (active && isEnabled() && (selection.getCursorPosition() >= data.start && selection.getCursorPosition() < data.end || (i == list.size() - 1 && selection.getCursorPosition() == text.length()))) {
|
||||
@@ -625,6 +785,27 @@ public class GuiScriptTextArea extends GuiNpcTextField {
|
||||
|
||||
// Draw go to line dialog (overlays everything)
|
||||
goToLineDialog.draw(xMouse, yMouse);
|
||||
|
||||
// Draw rename status indicator
|
||||
if (renameHandler.isActive()) {
|
||||
String status = renameHandler.getScopeDescription();
|
||||
String hint = "Enter \u2713 | Esc \u2715"; // Enter to confirm, Esc to cancel
|
||||
int statusWidth = Math.max(ClientProxy.Font.width(status), ClientProxy.Font.width(hint)) + 8;
|
||||
int statusX = x + width - statusWidth - 8;
|
||||
int statusY = y + height - 30;
|
||||
// Semi-transparent background
|
||||
drawRect(statusX - 2, statusY - 2, statusX + statusWidth + 2, statusY + 24, 0xDD1a1a2e);
|
||||
// Border (purple/blue for rename mode)
|
||||
int borderColor = 0xFF6677dd;
|
||||
drawRect(statusX - 2, statusY - 2, statusX + statusWidth + 2, statusY - 1, borderColor);
|
||||
drawRect(statusX - 2, statusY + 23, statusX + statusWidth + 2, statusY + 24, borderColor);
|
||||
drawRect(statusX - 2, statusY - 2, statusX - 1, statusY + 24, borderColor);
|
||||
drawRect(statusX + statusWidth + 1, statusY - 2, statusX + statusWidth + 2, statusY + 24, borderColor);
|
||||
// Status text (top line)
|
||||
ClientProxy.Font.drawString(status, statusX + 4, statusY + 2, 0xFFccddff);
|
||||
// Hint text (bottom line - dimmer)
|
||||
ClientProxy.Font.drawString(hint, statusX + 4, statusY + 13, 0xAA88aacc);
|
||||
}
|
||||
|
||||
KEYS_OVERLAY.draw(xMouse, yMouse, wheelDelta);
|
||||
}
|
||||
@@ -928,11 +1109,24 @@ public class GuiScriptTextArea extends GuiNpcTextField {
|
||||
unfocusAll();
|
||||
goToLineDialog.toggle();
|
||||
});
|
||||
|
||||
// RENAME: Start rename refactoring (Shift+F6)
|
||||
KEYS.RENAME.setTask(e -> {
|
||||
if (!e.isPress() || !openBoxes.get())
|
||||
return;
|
||||
|
||||
unfocusAll();
|
||||
if (!renameHandler.isActive()) {
|
||||
renameHandler.startRename();
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
public void unfocusAll() {
|
||||
if (searchBar.hasFocus()) searchBar.unfocus();
|
||||
if (goToLineDialog.hasFocus()) goToLineDialog.unfocus();
|
||||
if (renameHandler.isActive())
|
||||
renameHandler.cancel();
|
||||
}
|
||||
// ==================== KEYBOARD INPUT HANDLING ====================
|
||||
|
||||
@@ -943,6 +1137,10 @@ public class GuiScriptTextArea extends GuiNpcTextField {
|
||||
@Override
|
||||
public boolean textboxKeyTyped(char c, int i) {
|
||||
KEYS_OVERLAY.keyTyped(c, i);
|
||||
|
||||
// Handle rename refactor input first if active
|
||||
if (renameHandler.isActive() && renameHandler.keyTyped(c, i))
|
||||
return true;
|
||||
|
||||
// Handle Go To Line dialog input first if it has focus
|
||||
if (goToLineDialog.isVisible() &&goToLineDialog.keyTyped(c, i))
|
||||
@@ -1543,7 +1741,7 @@ public class GuiScriptTextArea extends GuiNpcTextField {
|
||||
}
|
||||
|
||||
public boolean closeOnEsc(){
|
||||
return !searchBar.isVisible() && !goToLineDialog.isVisible();
|
||||
return !searchBar.isVisible() && !goToLineDialog.isVisible() && !renameHandler.isActive();
|
||||
}
|
||||
|
||||
// ==================== KEYBOARD MODIFIERS ====================
|
||||
@@ -1603,7 +1801,9 @@ public class GuiScriptTextArea extends GuiNpcTextField {
|
||||
}
|
||||
|
||||
private void formatText() {
|
||||
IndentHelper.FormatResult result = IndentHelper.formatText(text, selection.getCursorPosition());
|
||||
// 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);
|
||||
setText(result.text);
|
||||
selection.reset(Math.max(0, Math.min(result.cursorPosition, this.text.length())));
|
||||
}
|
||||
@@ -1760,8 +1960,18 @@ public class GuiScriptTextArea extends GuiNpcTextField {
|
||||
// Determine whether click occurred inside the text area bounds
|
||||
this.active = xMouse >= this.x && xMouse < this.x + this.width && yMouse >= this.y && yMouse < this.y + this.height;
|
||||
if (this.active) {
|
||||
// Compute logical click position in text and reset selection/caret
|
||||
// Compute logical click position in text
|
||||
int clickPos = this.getSelectionPos(xMouse, yMouse);
|
||||
|
||||
// Check if rename refactoring is active and click is in the rename box
|
||||
if (renameHandler.isActive() && renameHandler.handleClick(clickPos)) {
|
||||
// Click was handled by rename handler - don't reset selection or do other click handling
|
||||
this.clicked = false;
|
||||
activeTextfield = this;
|
||||
return;
|
||||
}
|
||||
|
||||
// Normal click handling - reset selection/caret
|
||||
selection.reset(clickPos);
|
||||
selection.markActivity();
|
||||
|
||||
@@ -1818,6 +2028,7 @@ public class GuiScriptTextArea extends GuiNpcTextField {
|
||||
|
||||
searchBar.updateCursor();
|
||||
goToLineDialog.updateCursor();
|
||||
renameHandler.updateCursor();
|
||||
++this.cursorCounter;
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,846 @@
|
||||
package noppes.npcs.client.gui.util.script;
|
||||
|
||||
import noppes.npcs.client.gui.util.script.JavaTextContainer.LineData;
|
||||
|
||||
import java.util.ArrayList;
|
||||
import java.util.List;
|
||||
import java.util.regex.Matcher;
|
||||
import java.util.regex.Pattern;
|
||||
|
||||
/**
|
||||
* Handles IntelliJ-like rename refactoring with scope-aware renaming.
|
||||
*
|
||||
* Features:
|
||||
* - Scope detection: local variables rename only within their block, global fields rename everywhere
|
||||
* - Visual feedback: primary occurrence has white border, others just highlighted
|
||||
* - ESC cancels, Enter confirms
|
||||
* - Live preview as you type the new name
|
||||
* - Full word selection by default when starting rename
|
||||
* - Allows empty word during editing (shows empty box)
|
||||
* - Click support within rename box
|
||||
*/
|
||||
public class RenameRefactorHandler {
|
||||
|
||||
// ==================== STATE ====================
|
||||
private boolean active = false;
|
||||
private String initialWord = ""; // The word when rename started (for undo grouping)
|
||||
private String originalWord = ""; // Current baseline for live rename
|
||||
private String currentWord = ""; // Current word being typed
|
||||
private int primaryOccurrenceStart = -1;
|
||||
private int primaryOccurrenceEnd = -1;
|
||||
private List<int[]> allOccurrences = new ArrayList<>();
|
||||
private ScopeInfo scope = null;
|
||||
private int cursorInWord = 0; // Cursor position within the word being renamed
|
||||
private boolean wordFullySelected = true; // Start with word fully selected
|
||||
|
||||
// For restoring original text on cancel
|
||||
private String originalText = "";
|
||||
private int originalCursorPos = 0;
|
||||
|
||||
// Callback interface
|
||||
private RenameCallback callback;
|
||||
|
||||
// ==================== CURSOR BLINK ====================
|
||||
private int cursorCounter = 0;
|
||||
private long lastInputTime = 0;
|
||||
|
||||
// Pattern for identifiers
|
||||
private static final Pattern IDENTIFIER = Pattern.compile("[a-zA-Z_][a-zA-Z0-9_]*");
|
||||
|
||||
/**
|
||||
* Callback interface for rename operations
|
||||
*/
|
||||
public interface RenameCallback {
|
||||
String getText();
|
||||
|
||||
void setText(String text);
|
||||
|
||||
void setTextWithoutUndo(String text); // Set text without creating undo entry
|
||||
|
||||
void pushUndoState(String text); // Push an undo state
|
||||
|
||||
List<LineData> getLines();
|
||||
|
||||
int getCursorPosition();
|
||||
|
||||
SelectionState getSelectionState();
|
||||
|
||||
void setCursorPosition(int pos);
|
||||
|
||||
void unfocusMainEditor();
|
||||
|
||||
void focusMainEditor();
|
||||
|
||||
int getGutterWidth();
|
||||
|
||||
int getLineHeight();
|
||||
|
||||
int getScrolledLine();
|
||||
|
||||
double getFractionalOffset();
|
||||
|
||||
void scrollToPosition(int pos);
|
||||
|
||||
JavaTextContainer getContainer();
|
||||
|
||||
int getViewportWidth(); // For determining if clicks are in rename box
|
||||
}
|
||||
|
||||
/**
|
||||
* Scope information for a variable
|
||||
*/
|
||||
public static class ScopeInfo {
|
||||
public final int startOffset;
|
||||
public final int endOffset;
|
||||
public final boolean isGlobal;
|
||||
public final String scopeType; // "global", "method", "block"
|
||||
|
||||
public ScopeInfo(int start, int end, boolean isGlobal, String type) {
|
||||
this.startOffset = start;
|
||||
this.endOffset = end;
|
||||
this.isGlobal = isGlobal;
|
||||
this.scopeType = type;
|
||||
}
|
||||
|
||||
public boolean containsPosition(int pos) {
|
||||
return pos >= startOffset && pos < endOffset;
|
||||
}
|
||||
}
|
||||
|
||||
public void setCallback(RenameCallback callback) {
|
||||
this.callback = callback;
|
||||
}
|
||||
|
||||
/**
|
||||
* Start rename refactoring at the current cursor position.
|
||||
* Selects the word under cursor and finds all occurrences within scope.
|
||||
*
|
||||
* @return true if rename mode was successfully started
|
||||
*/
|
||||
public boolean startRename() {
|
||||
if (callback == null)
|
||||
return false;
|
||||
|
||||
String text = callback.getText();
|
||||
int cursor = callback.getCursorPosition();
|
||||
|
||||
if (text == null || text.isEmpty())
|
||||
return false;
|
||||
|
||||
// Find word under cursor
|
||||
int[] wordBounds = findWordAtPosition(text, cursor);
|
||||
if (wordBounds == null)
|
||||
return false;
|
||||
|
||||
// Store original state for cancel AND for undo grouping
|
||||
originalText = text;
|
||||
originalCursorPos = cursor;
|
||||
|
||||
initialWord = text.substring(wordBounds[0], wordBounds[1]); // Remember for undo
|
||||
originalWord = initialWord;
|
||||
currentWord = initialWord;
|
||||
setSelection(wordBounds[0], wordBounds[1]);
|
||||
|
||||
// Start with FULL WORD SELECTED (cursor at end, word selected)
|
||||
cursorInWord = currentWord.length();
|
||||
wordFullySelected = true;
|
||||
|
||||
// Determine scope for this identifier - MUST check if local shadows global
|
||||
scope = determineScope(text, wordBounds[0], originalWord, callback.getContainer());
|
||||
|
||||
// Find all occurrences within scope
|
||||
findOccurrences(text, originalWord);
|
||||
|
||||
if (allOccurrences.isEmpty())
|
||||
return false;
|
||||
|
||||
active = true;
|
||||
markActivity();
|
||||
callback.unfocusMainEditor();
|
||||
|
||||
// Push initial undo state so we can restore to this point
|
||||
callback.pushUndoState(text);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Cancel rename operation and restore original state
|
||||
*/
|
||||
public void cancel() {
|
||||
if (!active)
|
||||
return;
|
||||
|
||||
// Restore original text
|
||||
if (callback != null && !originalText.isEmpty()) {
|
||||
callback.setText(originalText);
|
||||
callback.setCursorPosition(originalCursorPos);
|
||||
}
|
||||
|
||||
resetState();
|
||||
|
||||
if (callback != null) {
|
||||
callback.focusMainEditor();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Confirm rename operation and apply changes
|
||||
*/
|
||||
public void confirm() {
|
||||
if (!active || callback == null)
|
||||
return;
|
||||
|
||||
// If word is empty, restore original
|
||||
if (currentWord.isEmpty()) {
|
||||
cancel();
|
||||
return;
|
||||
}
|
||||
|
||||
// Final text is already applied - push as single undo state
|
||||
// The text was modified via setTextWithoutUndo, so push final state
|
||||
String finalText = callback.getText();
|
||||
callback.pushUndoState(finalText);
|
||||
|
||||
// Changes are already applied live, just exit rename mode
|
||||
int newCursorPos = primaryOccurrenceStart + cursorInWord;
|
||||
|
||||
resetState();
|
||||
|
||||
callback.focusMainEditor();
|
||||
callback.setCursorPosition(Math.max(0, newCursorPos));
|
||||
}
|
||||
|
||||
private void resetState() {
|
||||
active = false;
|
||||
initialWord = "";
|
||||
originalWord = "";
|
||||
currentWord = "";
|
||||
primaryOccurrenceStart = -1;
|
||||
primaryOccurrenceEnd = -1;
|
||||
allOccurrences.clear();
|
||||
scope = null;
|
||||
originalText = "";
|
||||
originalCursorPos = 0;
|
||||
wordFullySelected = false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Handle keyboard input during rename
|
||||
* @return true if input was consumed
|
||||
*/
|
||||
public boolean keyTyped(char c, int keyCode) {
|
||||
if (!active)
|
||||
return false;
|
||||
|
||||
// ESC - cancel
|
||||
if (keyCode == org.lwjgl.input.Keyboard.KEY_ESCAPE) {
|
||||
cancel();
|
||||
return true;
|
||||
}
|
||||
|
||||
// Enter - confirm
|
||||
if (keyCode == org.lwjgl.input.Keyboard.KEY_RETURN) {
|
||||
confirm();
|
||||
return true;
|
||||
}
|
||||
|
||||
// Tab - confirm and move on
|
||||
if (keyCode == org.lwjgl.input.Keyboard.KEY_TAB) {
|
||||
confirm();
|
||||
return true;
|
||||
}
|
||||
|
||||
// Any navigation or editing key clears full selection mode
|
||||
boolean wasFullySelected = wordFullySelected;
|
||||
|
||||
// Backspace
|
||||
if (keyCode == org.lwjgl.input.Keyboard.KEY_BACK) {
|
||||
if (wasFullySelected) {
|
||||
// Delete entire word
|
||||
currentWord = "";
|
||||
cursorInWord = 0;
|
||||
wordFullySelected = false;
|
||||
applyLiveRename();
|
||||
markActivity();
|
||||
} else if (cursorInWord > 0 && currentWord.length() > 0) {
|
||||
String before = currentWord.substring(0, cursorInWord - 1);
|
||||
String after = currentWord.substring(cursorInWord);
|
||||
currentWord = before + after;
|
||||
cursorInWord--;
|
||||
applyLiveRename();
|
||||
markActivity();
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// Delete
|
||||
if (keyCode == org.lwjgl.input.Keyboard.KEY_DELETE) {
|
||||
if (wasFullySelected) {
|
||||
// Delete entire word
|
||||
currentWord = "";
|
||||
cursorInWord = 0;
|
||||
wordFullySelected = false;
|
||||
applyLiveRename();
|
||||
markActivity();
|
||||
} else if (cursorInWord < currentWord.length()) {
|
||||
String before = currentWord.substring(0, cursorInWord);
|
||||
String after = currentWord.substring(cursorInWord + 1);
|
||||
currentWord = before + after;
|
||||
applyLiveRename();
|
||||
markActivity();
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// Left arrow
|
||||
if (keyCode == org.lwjgl.input.Keyboard.KEY_LEFT) {
|
||||
wordFullySelected = false;
|
||||
if (cursorInWord > 0) {
|
||||
cursorInWord--;
|
||||
markActivity();
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// Right arrow
|
||||
if (keyCode == org.lwjgl.input.Keyboard.KEY_RIGHT) {
|
||||
wordFullySelected = false;
|
||||
if (cursorInWord < currentWord.length()) {
|
||||
cursorInWord++;
|
||||
markActivity();
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
// Home
|
||||
if (keyCode == org.lwjgl.input.Keyboard.KEY_HOME) {
|
||||
wordFullySelected = false;
|
||||
cursorInWord = 0;
|
||||
markActivity();
|
||||
return true;
|
||||
}
|
||||
|
||||
// End
|
||||
if (keyCode == org.lwjgl.input.Keyboard.KEY_END) {
|
||||
wordFullySelected = false;
|
||||
cursorInWord = currentWord.length();
|
||||
markActivity();
|
||||
return true;
|
||||
}
|
||||
|
||||
// Ctrl+A - select all
|
||||
if (keyCode == org.lwjgl.input.Keyboard.KEY_A &&
|
||||
org.lwjgl.input.Keyboard.isKeyDown(org.lwjgl.input.Keyboard.KEY_LCONTROL)) {
|
||||
wordFullySelected = true;
|
||||
cursorInWord = currentWord.length();
|
||||
markActivity();
|
||||
return true;
|
||||
}
|
||||
|
||||
// Character input - only valid identifier characters
|
||||
if (isValidIdentifierChar(c, (wasFullySelected || currentWord.isEmpty()) && cursorInWord == 0)) {
|
||||
if (wasFullySelected) {
|
||||
// Replace entire word with this character
|
||||
currentWord = String.valueOf(c);
|
||||
cursorInWord = 1;
|
||||
wordFullySelected = false;
|
||||
} else {
|
||||
String before = currentWord.substring(0, cursorInWord);
|
||||
String after = currentWord.substring(cursorInWord);
|
||||
currentWord = before + c + after;
|
||||
cursorInWord++;
|
||||
}
|
||||
applyLiveRename();
|
||||
markActivity();
|
||||
return true;
|
||||
}
|
||||
|
||||
// Block other input while in rename mode
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if string is a valid identifier
|
||||
*/
|
||||
private boolean isValidIdentifier(String s) {
|
||||
if (s == null || s.isEmpty())
|
||||
return false;
|
||||
return IDENTIFIER.matcher(s).matches();
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if character is valid for an identifier
|
||||
*/
|
||||
private boolean isValidIdentifierChar(char c, boolean isFirst) {
|
||||
if (isFirst) {
|
||||
return Character.isLetter(c) || c == '_';
|
||||
}
|
||||
return Character.isLetterOrDigit(c) || c == '_';
|
||||
}
|
||||
|
||||
/**
|
||||
* Apply rename changes live as user types (without creating undo entries)
|
||||
*/
|
||||
private void applyLiveRename() {
|
||||
if (callback == null)
|
||||
return;
|
||||
|
||||
String text = callback.getText();
|
||||
|
||||
// Calculate new primary position after rename
|
||||
int occurrencesBefore = 0;
|
||||
for (int[] occ : allOccurrences) {
|
||||
if (occ[0] < primaryOccurrenceStart) {
|
||||
occurrencesBefore++;
|
||||
}
|
||||
}
|
||||
int lengthDiff = currentWord.length() - originalWord.length();
|
||||
int newPrimaryStart = primaryOccurrenceStart + (occurrencesBefore * lengthDiff);
|
||||
|
||||
// Apply rename (even if currentWord is empty - we allow temporary empty state)
|
||||
String newText = applyRename(text, currentWord);
|
||||
callback.setTextWithoutUndo(newText); // Don't create undo entry for each keystroke
|
||||
|
||||
// Update tracking for current word
|
||||
originalWord = currentWord;
|
||||
|
||||
// Recalculate occurrences based on the new word
|
||||
// If empty, we still keep the positions tracked (just with empty strings)
|
||||
if (!currentWord.isEmpty()) {
|
||||
findOccurrences(newText, currentWord);
|
||||
} else {
|
||||
// For empty word, update positions based on length difference
|
||||
updateOccurrencePositionsForEmpty(newPrimaryStart);
|
||||
}
|
||||
|
||||
// Update primary occurrence tracking
|
||||
if (!allOccurrences.isEmpty()) {
|
||||
for (int[] occ : allOccurrences) {
|
||||
if (Math.abs(occ[0] - newPrimaryStart) < 2) {
|
||||
setSelection(occ[0], occ[1]);
|
||||
break;
|
||||
}
|
||||
}
|
||||
} else if (currentWord.isEmpty()) {
|
||||
// Keep tracking the position even when empty
|
||||
setSelection(newPrimaryStart, newPrimaryStart);
|
||||
}
|
||||
}
|
||||
|
||||
private void setSelection(int start, int end) {
|
||||
primaryOccurrenceStart = start;
|
||||
primaryOccurrenceEnd = end;
|
||||
if (callback != null)
|
||||
callback.getSelectionState().setSelection(start, end);
|
||||
}
|
||||
|
||||
/**
|
||||
* Update occurrence positions when word is empty (for visual tracking)
|
||||
*/
|
||||
private void updateOccurrencePositionsForEmpty(int newPrimaryStart) {
|
||||
// Just keep the primary occurrence position for rendering the empty box
|
||||
allOccurrences.clear();
|
||||
allOccurrences.add(new int[]{newPrimaryStart, newPrimaryStart});
|
||||
}
|
||||
|
||||
/**
|
||||
* Apply rename to all occurrences in text
|
||||
*/
|
||||
private String applyRename(String text, String newName) {
|
||||
if (allOccurrences.isEmpty() || newName.isEmpty())
|
||||
return text;
|
||||
|
||||
StringBuilder result = new StringBuilder();
|
||||
int lastEnd = 0;
|
||||
|
||||
// Sort occurrences by position
|
||||
List<int[]> sorted = new ArrayList<>(allOccurrences);
|
||||
sorted.sort((a, b) -> Integer.compare(a[0], b[0]));
|
||||
|
||||
for (int[] occ : sorted) {
|
||||
if (occ[0] >= lastEnd && occ[1] <= text.length()) {
|
||||
result.append(text, lastEnd, occ[0]);
|
||||
result.append(newName);
|
||||
lastEnd = occ[1];
|
||||
}
|
||||
}
|
||||
result.append(text.substring(lastEnd));
|
||||
|
||||
return result.toString();
|
||||
}
|
||||
|
||||
/**
|
||||
* Find all occurrences of the identifier within scope
|
||||
*/
|
||||
private void findOccurrences(String text, String word) {
|
||||
allOccurrences.clear();
|
||||
|
||||
if (word.isEmpty() || scope == null)
|
||||
return;
|
||||
|
||||
// Get excluded ranges (strings and comments)
|
||||
List<int[]> excluded = MethodBlock.getExcludedRanges(text);
|
||||
|
||||
Pattern pattern = Pattern.compile("\\b" + Pattern.quote(word) + "\\b");
|
||||
Matcher m = pattern.matcher(text);
|
||||
|
||||
while (m.find()) {
|
||||
int start = m.start();
|
||||
int end = m.end();
|
||||
|
||||
// Skip if in string or comment
|
||||
if (isInExcludedRange(start, excluded))
|
||||
continue;
|
||||
|
||||
// Check if within scope
|
||||
if (scope.isGlobal || scope.containsPosition(start)) {
|
||||
allOccurrences.add(new int[]{start, end});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if position is in an excluded range
|
||||
*/
|
||||
private boolean isInExcludedRange(int pos, List<int[]> ranges) {
|
||||
for (int[] range : ranges) {
|
||||
if (pos >= range[0] && pos < range[1])
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Find word boundaries at a given position
|
||||
*/
|
||||
private int[] findWordAtPosition(String text, int pos) {
|
||||
if (pos < 0 || pos > text.length())
|
||||
return null;
|
||||
|
||||
// Find start of word
|
||||
int start = pos;
|
||||
while (start > 0 && isIdentifierChar(text.charAt(start - 1))) {
|
||||
start--;
|
||||
}
|
||||
|
||||
// Find end of word
|
||||
int end = pos;
|
||||
while (end < text.length() && isIdentifierChar(text.charAt(end))) {
|
||||
end++;
|
||||
}
|
||||
|
||||
if (start == end)
|
||||
return null;
|
||||
|
||||
// Validate it's a proper identifier
|
||||
String word = text.substring(start, end);
|
||||
if (!IDENTIFIER.matcher(word).matches())
|
||||
return null;
|
||||
|
||||
return new int[]{start, end};
|
||||
}
|
||||
|
||||
private boolean isIdentifierChar(char c) {
|
||||
return Character.isLetterOrDigit(c) || c == '_';
|
||||
}
|
||||
|
||||
/**
|
||||
* Determine the scope for a variable at the given position.
|
||||
* Key insight: Local variables shadow global variables within their scope.
|
||||
* We need to check if the cursor is within the scope of a local declaration.
|
||||
*/
|
||||
private ScopeInfo determineScope(String text, int position, String varName, JavaTextContainer container) {
|
||||
List<MethodBlock> methods = MethodBlock.collectMethodBlocks(text);
|
||||
|
||||
// First, check if this is a global field declaration (outside any method)
|
||||
boolean isGlobalField = isGlobalFieldDeclaration(text, varName, methods);
|
||||
|
||||
// Check if cursor is outside all methods - definitely global scope
|
||||
boolean insideMethod = false;
|
||||
MethodBlock containingMethod = null;
|
||||
for (MethodBlock method : methods) {
|
||||
if (method.containsPosition(position)) {
|
||||
insideMethod = true;
|
||||
containingMethod = method;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!insideMethod || containingMethod == null) {
|
||||
// Cursor is outside methods - must be global scope
|
||||
return new ScopeInfo(0, text.length(), true, "global");
|
||||
}
|
||||
|
||||
// Cursor is inside a method
|
||||
// Check if it's a method parameter first
|
||||
String methodHeader = text.substring(containingMethod.startOffset,
|
||||
Math.min(containingMethod.startOffset + 500, containingMethod.endOffset));
|
||||
int parenStart = methodHeader.indexOf('(');
|
||||
int parenEnd = methodHeader.indexOf(')');
|
||||
if (parenStart >= 0 && parenEnd > parenStart) {
|
||||
String params = methodHeader.substring(parenStart + 1, parenEnd);
|
||||
Pattern paramPattern = Pattern.compile("\\b" + Pattern.quote(varName) + "\\b");
|
||||
if (paramPattern.matcher(params).find()) {
|
||||
// It's a parameter - scope to method
|
||||
return new ScopeInfo(containingMethod.startOffset, containingMethod.endOffset, false, "parameter");
|
||||
}
|
||||
}
|
||||
|
||||
// Check if there's a local variable with this name in the method
|
||||
if (containingMethod.localVariables.contains(varName)) {
|
||||
// Find where the local variable is declared
|
||||
int localDeclPosition = findLocalDeclarationPosition(text, varName, containingMethod);
|
||||
|
||||
if (localDeclPosition >= 0 && position >= localDeclPosition) {
|
||||
// Cursor is at or after the local declaration - this is the local variable
|
||||
int[] blockBounds = findInnermostBlockWithDeclaration(text, position, varName, containingMethod);
|
||||
if (blockBounds != null) {
|
||||
return new ScopeInfo(blockBounds[0], blockBounds[1], false, "block");
|
||||
}
|
||||
return new ScopeInfo(containingMethod.startOffset, containingMethod.endOffset, false, "local");
|
||||
} else if (isGlobalField) {
|
||||
// Cursor is BEFORE the local declaration - must be referring to global
|
||||
// This is the shadowing case
|
||||
return new ScopeInfo(0, text.length(), true, "global");
|
||||
}
|
||||
}
|
||||
|
||||
// No local variable with this name - check if it's a global field
|
||||
if (isGlobalField) {
|
||||
return new ScopeInfo(0, text.length(), true, "global");
|
||||
}
|
||||
|
||||
// Unknown variable - default to method scope as fallback
|
||||
return new ScopeInfo(containingMethod.startOffset, containingMethod.endOffset, false, "method");
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a variable is declared as a global field (outside any method)
|
||||
*/
|
||||
private boolean isGlobalFieldDeclaration(String text, String varName, List<MethodBlock> methods) {
|
||||
Matcher m = JavaTextContainer.GLOBAL_FIELD_DECL.matcher(text);
|
||||
while (m.find()) {
|
||||
if (m.group(2).equals(varName)) {
|
||||
int pos = m.start(2);
|
||||
// Verify it's not inside a method
|
||||
boolean insideMethod = false;
|
||||
for (MethodBlock method : methods) {
|
||||
if (method.containsPosition(pos)) {
|
||||
insideMethod = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!insideMethod) {
|
||||
return true;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Find the position of the first local variable declaration with the given name
|
||||
*/
|
||||
private int findLocalDeclarationPosition(String text, String varName, MethodBlock method) {
|
||||
// Pattern for local variable declaration: Type varName = or Type varName;
|
||||
Pattern localDecl = Pattern.compile("\\b\\w+\\s+" + Pattern.quote(varName) + "\\s*[=;,)]");
|
||||
String methodText = text.substring(method.startOffset, Math.min(method.endOffset, text.length()));
|
||||
Matcher m = localDecl.matcher(methodText);
|
||||
|
||||
// Skip past the method header (parameters) to find true local declarations
|
||||
int bodyStart = methodText.indexOf('{');
|
||||
if (bodyStart < 0)
|
||||
bodyStart = 0;
|
||||
|
||||
while (m.find()) {
|
||||
if (m.start() >= bodyStart) {
|
||||
return method.startOffset + m.start();
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
/**
|
||||
* Find the innermost brace block that contains both the position and a declaration of varName
|
||||
*/
|
||||
private int[] findInnermostBlockWithDeclaration(String text, int position, String varName, MethodBlock method) {
|
||||
List<int[]> excluded = MethodBlock.getExcludedRanges(text);
|
||||
|
||||
// Find all brace blocks within the method
|
||||
List<int[]> blocks = new ArrayList<>();
|
||||
List<Integer> braceStack = new ArrayList<>();
|
||||
|
||||
for (int i = method.startOffset; i < method.endOffset && i < text.length(); i++) {
|
||||
if (isInExcludedRange(i, excluded))
|
||||
continue;
|
||||
|
||||
char c = text.charAt(i);
|
||||
if (c == '{') {
|
||||
braceStack.add(i);
|
||||
} else if (c == '}') {
|
||||
if (!braceStack.isEmpty()) {
|
||||
int openPos = braceStack.remove(braceStack.size() - 1);
|
||||
blocks.add(new int[]{openPos, i + 1});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Find smallest block containing position that has a declaration of varName
|
||||
int[] best = null;
|
||||
int bestSize = Integer.MAX_VALUE;
|
||||
|
||||
Pattern declPattern = Pattern.compile("\\b\\w+\\s+" + Pattern.quote(varName) + "\\s*[=;,)]");
|
||||
|
||||
for (int[] block : blocks) {
|
||||
if (block[0] <= position && block[1] >= position) {
|
||||
int size = block[1] - block[0];
|
||||
if (size < bestSize) {
|
||||
// Check if this block contains a declaration of varName
|
||||
String blockText = text.substring(block[0], Math.min(block[1], text.length()));
|
||||
if (declPattern.matcher(blockText).find()) {
|
||||
best = block;
|
||||
bestSize = size;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return best;
|
||||
}
|
||||
|
||||
// ==================== RENDERING ====================
|
||||
|
||||
/**
|
||||
* Get all occurrences for rendering highlights
|
||||
*/
|
||||
public List<int[]> getOccurrences() {
|
||||
return allOccurrences;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get primary occurrence (the one under cursor when rename started)
|
||||
*/
|
||||
public int[] getPrimaryOccurrence() {
|
||||
if (!active)
|
||||
return null;
|
||||
return new int[]{primaryOccurrenceStart, primaryOccurrenceEnd};
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a given occurrence is the primary one
|
||||
*/
|
||||
public boolean isPrimaryOccurrence(int start) {
|
||||
return start == primaryOccurrenceStart;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get cursor position within the rename word for rendering
|
||||
*/
|
||||
public int getCursorInWord() {
|
||||
return cursorInWord;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if word is fully selected (for visual rendering)
|
||||
*/
|
||||
public boolean isWordFullySelected() {
|
||||
return wordFullySelected;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get the current word being renamed
|
||||
*/
|
||||
public String getCurrentWord() {
|
||||
return currentWord;
|
||||
}
|
||||
|
||||
// ==================== MOUSE HANDLING ====================
|
||||
|
||||
/**
|
||||
* Handle mouse click within the rename box area.
|
||||
*
|
||||
* @param clickPosInText The text position where the click occurred
|
||||
* @return true if the click was within the primary occurrence box, false otherwise
|
||||
*/
|
||||
public boolean handleClick(int clickPosInText) {
|
||||
if (!active)
|
||||
return false;
|
||||
|
||||
// Check if click is within the primary occurrence bounds
|
||||
if (clickPosInText >= primaryOccurrenceStart &&
|
||||
clickPosInText <= primaryOccurrenceEnd) {
|
||||
|
||||
// Calculate position within the word
|
||||
int relativePos = clickPosInText - primaryOccurrenceStart;
|
||||
|
||||
// Clamp to valid range
|
||||
cursorInWord = Math.max(0, Math.min(relativePos, currentWord.length()));
|
||||
|
||||
// Clear full selection mode on click
|
||||
wordFullySelected = false;
|
||||
|
||||
markActivity();
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if a text position is within the primary rename occurrence
|
||||
*/
|
||||
public boolean isPositionInPrimaryOccurrence(int pos) {
|
||||
if (!active)
|
||||
return false;
|
||||
return pos >= primaryOccurrenceStart && pos <= primaryOccurrenceEnd;
|
||||
}
|
||||
|
||||
// ==================== STATUS ====================
|
||||
|
||||
public boolean isActive() {
|
||||
return active;
|
||||
}
|
||||
|
||||
public void updateCursor() {
|
||||
cursorCounter++;
|
||||
}
|
||||
|
||||
private void markActivity() {
|
||||
lastInputTime = System.currentTimeMillis();
|
||||
}
|
||||
|
||||
public boolean shouldShowCursor() {
|
||||
boolean recentInput = System.currentTimeMillis() - lastInputTime < 500;
|
||||
return recentInput || (cursorCounter / 10) % 2 == 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get scope type description for status display
|
||||
*/
|
||||
public String getScopeDescription() {
|
||||
if (scope == null)
|
||||
return "";
|
||||
switch (scope.scopeType) {
|
||||
case "global":
|
||||
return "Renaming in file (" + allOccurrences.size() + " occurrences)";
|
||||
case "parameter":
|
||||
return "Renaming parameter (" + allOccurrences.size() + " occurrences)";
|
||||
case "local":
|
||||
return "Renaming local variable (" + allOccurrences.size() + " occurrences)";
|
||||
case "method":
|
||||
return "Renaming in method (" + allOccurrences.size() + " occurrences)";
|
||||
case "block":
|
||||
return "Renaming in block (" + allOccurrences.size() + " occurrences)";
|
||||
default:
|
||||
return "Renaming (" + allOccurrences.size() + " occurrences)";
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get number of occurrences that will be renamed
|
||||
*/
|
||||
public int getOccurrenceCount() {
|
||||
return allOccurrences.size();
|
||||
}
|
||||
}
|
||||
@@ -24,6 +24,9 @@ public class ScriptEditorKeys extends KeyPresetManager {
|
||||
|
||||
// Navigation
|
||||
public final KeyPreset GO_TO_LINE = add("Go to Line").setDefaultState(Keyboard.KEY_G, true, false, false);
|
||||
|
||||
// Refactoring
|
||||
public final KeyPreset RENAME = add("Rename/Refactor").setDefaultState(Keyboard.KEY_F6, false, true, false);
|
||||
|
||||
public ScriptEditorKeys() {
|
||||
super("script_editor");
|
||||
|
||||
Reference in new issue
Block a user