private void setLastPattern(@NotNull Editor editor, @NotNull String lastPattern) {
this.lastPattern = lastPattern;
VimPlugin.getRegister()
.storeTextInternal(
editor, new TextRange(-1, -1), lastPattern, SelectionType.CHARACTER_WISE, '/', false);
VimPlugin.getHistory().addEntry(HistoryGroup.SEARCH, lastPattern);
}
public void actionPerformed(@NotNull AnActionEvent event) {
if (logger.isDebugEnabled()) {
logger.debug("actionPerformed=" + event);
}
if (!VimPlugin.isEnabled()) {
return;
}
if (event.getInputEvent() instanceof KeyEvent) {
KeyEvent ke = (KeyEvent) event.getInputEvent();
Editor editor = event.getData(PlatformDataKeys.EDITOR);
if (editor != null) {
KeyStroke key = KeyStroke.getKeyStrokeForEvent(ke);
KeyHandler.getInstance().handleKey(editor, key, event.getDataContext());
} else {
if (ExEntryPanel.getInstance().isActive()) {
KeyEvent e =
new KeyEvent(
ke.getComponent(),
ke.getID(),
ke.getWhen(),
ke.getModifiers(),
ke.getKeyCode(),
ke.getKeyChar(),
ke.getKeyLocation());
ExEntryPanel.getInstance().processKey(e);
}
}
}
}
public boolean execute(
@NotNull Editor editor,
@NotNull DataContext context,
int count,
int rawCount,
@Nullable Argument argument) {
return VimPlugin.getChange().changeCaseToggleCharacter(editor, count);
}
private void splitWindow(
int orientation, @NotNull DataContext context, @NotNull String filename) {
final Project project = PlatformDataKeys.PROJECT.getData(context);
final FileEditorManagerEx fileEditorManager = FileEditorManagerEx.getInstanceEx(project);
VirtualFile virtualFile = null;
if (filename.length() > 0 && project != null) {
virtualFile = VimPlugin.getFile().findFile(filename, project);
if (virtualFile == null) {
VimPlugin.showMessage("Could not find file: " + filename);
return;
}
}
final EditorWindow editorWindow = fileEditorManager.getSplitters().getCurrentWindow();
if (editorWindow != null) {
editorWindow.split(orientation, true, virtualFile, true);
}
}
public int search(
@NotNull Editor editor, @NotNull String command, int count, int flags, boolean moveCursor) {
int res = search(editor, command, editor.getCaretModel().getOffset(), count, flags);
if (res != -1 && moveCursor) {
VimPlugin.getMark().saveJumpLocation(editor);
MotionGroup.moveCaret(editor, res);
}
return res;
}
public void documentChanged(@NotNull DocumentEvent event) {
if (!VimPlugin.isEnabled()) {
return;
}
Project[] projs = ProjectManager.getInstance().getOpenProjects();
for (Project proj : projs) {
Editor[] editors = EditorFactory.getInstance().getEditors(event.getDocument(), proj);
for (Editor editor : editors) {
Collection hls = EditorData.getLastHighlights(editor);
if (hls == null) {
continue;
}
int soff = event.getOffset();
int eoff = soff + event.getNewLength();
if (logger.isDebugEnabled()) {
logger.debug("hls=" + hls);
logger.debug("event=" + event);
}
Iterator iter = hls.iterator();
while (iter.hasNext()) {
RangeHighlighter rh = (RangeHighlighter) iter.next();
if (!rh.isValid() || (eoff >= rh.getStartOffset() && soff <= rh.getEndOffset())) {
iter.remove();
editor.getMarkupModel().removeHighlighter(rh);
}
}
int sl = editor.offsetToLogicalPosition(soff).line;
int el = editor.offsetToLogicalPosition(eoff).line;
VimPlugin.getSearch().highlightSearchLines(editor, false, sl, el);
hls = EditorData.getLastHighlights(editor);
if (logger.isDebugEnabled()) {
logger.debug("sl=" + sl + ", el=" + el);
logger.debug("hls=" + hls);
}
}
}
}
public int getOffset(
@NotNull Editor editor,
DataContext context,
int count,
int rawCount,
@NotNull Argument argument) {
final String command = argument.getString();
if (command == null) {
return -1;
}
return VimPlugin.getSearch().search(editor, command, count, Command.FLAG_SEARCH_FWD, false);
}
public boolean execute(
@NotNull Editor editor,
@NotNull DataContext context,
int count,
int rawCount,
@Nullable Argument argument) {
if (argument != null) {
VimPlugin.getChange().indentMotion(editor, context, count, rawCount, argument, 1);
return true;
} else {
return false;
}
}
/**
* Moves the cursor to the line entered by the user
*
* @param editor The editor to perform the action in.
* @param context The data context
* @param cmd The complete Ex command including range, command, and arguments
* @return True if able to perform the command, false if not
*/
public boolean execute(
@NotNull Editor editor, @NotNull DataContext context, @NotNull ExCommand cmd) {
int count = cmd.getLine(editor, context);
int max = EditorHelper.getLineCount(editor);
if (count >= max) {
count = max - 1;
}
if (count >= 0) {
MotionGroup.moveCaret(
editor, VimPlugin.getMotion().moveCaretToLineStartSkipLeading(editor, count));
return true;
} else {
MotionGroup.moveCaret(editor, 0);
}
return false;
}
@NotNull
private String processKey(String key, int start, int end) {
if (logger.isDebugEnabled()) {
logger.debug("process " + key + " " + start + "," + end);
}
StringBuffer res = new StringBuffer();
res.append(" # ").append(key).append(" ").append("history\n");
String spaces = " ";
List<HistoryGroup.HistoryEntry> entries = VimPlugin.getHistory().getEntries(key, start, end);
for (HistoryGroup.HistoryEntry entry : entries) {
String num = Integer.toString(entry.getNumber());
res.append(spaces.substring(num.length()))
.append(num)
.append(" ")
.append(entry.getEntry())
.append("\n");
}
return res.toString();
}
private int findItOffset(
@NotNull Editor editor, int startOffset, int count, int dir, boolean noSmartCase) {
boolean wrap = Options.getInstance().isSet("wrapscan");
TextRange range = findIt(editor, startOffset, count, dir, noSmartCase, wrap, true, true);
if (range == null) {
return -1;
}
// highlightMatch(editor, range.getStartOffset(), range.getEndOffset());
ParsePosition pp = new ParsePosition(0);
int res = range.getStartOffset();
if (lastOffset == null) {
return -1;
}
if (lastOffset.length() == 0) {
return range.getStartOffset();
} else if (Character.isDigit(lastOffset.charAt(0))
|| lastOffset.charAt(0) == '+'
|| lastOffset.charAt(0) == '-') {
int lineOffset = 0;
if (lastOffset.equals("+")) {
lineOffset = 1;
} else if (lastOffset.equals("-")) {
lineOffset = -1;
} else {
if (lastOffset.charAt(0) == '+') {
lastOffset = lastOffset.substring(1);
}
NumberFormat nf = NumberFormat.getIntegerInstance();
pp = new ParsePosition(0);
Number num = nf.parse(lastOffset, pp);
if (num != null) {
lineOffset = num.intValue();
}
}
int line = editor.offsetToLogicalPosition(range.getStartOffset()).line;
int newLine = EditorHelper.normalizeLine(editor, line + lineOffset);
res = VimPlugin.getMotion().moveCaretToLineStart(editor, newLine);
} else if ("ebs".indexOf(lastOffset.charAt(0)) != -1) {
int charOffset = 0;
if (lastOffset.length() >= 2) {
if ("+-".indexOf(lastOffset.charAt(1)) != -1) {
charOffset = 1;
}
NumberFormat nf = NumberFormat.getIntegerInstance();
pp = new ParsePosition(lastOffset.charAt(1) == '+' ? 2 : 1);
Number num = nf.parse(lastOffset, pp);
if (num != null) {
charOffset = num.intValue();
}
}
int base = range.getStartOffset();
if (lastOffset.charAt(0) == 'e') {
base = range.getEndOffset() - 1;
}
res = Math.max(0, Math.min(base + charOffset, EditorHelper.getFileSize(editor) - 1));
}
int ppos = pp.getIndex();
if (ppos < lastOffset.length() - 1 && lastOffset.charAt(ppos) == ';') {
int flags;
if (lastOffset.charAt(ppos + 1) == '/') {
flags = Command.FLAG_SEARCH_FWD;
} else if (lastOffset.charAt(ppos + 1) == '?') {
flags = Command.FLAG_SEARCH_REV;
} else {
return res;
}
if (lastOffset.length() - ppos > 2) {
ppos++;
}
res = search(editor, lastOffset.substring(ppos + 1), res, 1, flags);
return res;
} else {
return res;
}
}
@NotNull
public DigraphResult processKey(@NotNull KeyStroke key, @NotNull Editor editor) {
switch (digraphState) {
case DIG_STATE_START:
logger.debug("DIG_STATE_START");
if (key.getKeyCode() == KeyEvent.VK_K && (key.getModifiers() & KeyEvent.CTRL_MASK) != 0) {
logger.debug("found Ctrl-K");
digraphState = DIG_STATE_DIG_ONE;
return DigraphResult.OK;
} else if ((key.getKeyCode() == KeyEvent.VK_V || key.getKeyCode() == KeyEvent.VK_Q)
&& (key.getModifiers() & KeyEvent.CTRL_MASK) != 0) {
logger.debug("found Ctrl-V");
digraphState = DIG_STATE_CODE_START;
codeChars = new char[8];
codeCnt = 0;
return DigraphResult.OK;
} else {
return new DigraphResult(key);
}
case DIG_STATE_DIG_ONE:
logger.debug("DIG_STATE_DIG_ONE");
if (key.getKeyChar() != KeyEvent.CHAR_UNDEFINED) {
digraphChar = key.getKeyChar();
digraphState = DIG_STATE_DIG_TWO;
return DigraphResult.OK;
} else {
digraphState = DIG_STATE_START;
return DigraphResult.BAD;
}
case DIG_STATE_DIG_TWO:
logger.debug("DIG_STATE_DIG_TWO");
digraphState = DIG_STATE_START;
if (key.getKeyChar() != KeyEvent.CHAR_UNDEFINED) {
char ch = VimPlugin.getDigraph().getDigraph(digraphChar, key.getKeyChar());
return new DigraphResult(KeyStroke.getKeyStroke(ch));
}
return DigraphResult.BAD;
case DIG_STATE_CODE_START:
logger.debug("DIG_STATE_CODE_START");
switch (key.getKeyChar()) {
case 'o':
case 'O':
codeMax = 3;
digraphState = DIG_STATE_CODE_CHAR;
codeType = 8;
logger.debug("Octal");
return DigraphResult.OK;
case 'x':
case 'X':
codeMax = 2;
digraphState = DIG_STATE_CODE_CHAR;
codeType = 16;
logger.debug("hex2");
return DigraphResult.OK;
case 'u':
codeMax = 4;
digraphState = DIG_STATE_CODE_CHAR;
codeType = 16;
logger.debug("hex4");
return DigraphResult.OK;
case 'U':
codeMax = 8;
digraphState = DIG_STATE_CODE_CHAR;
codeType = 16;
logger.debug("hex8");
return DigraphResult.OK;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
codeMax = 3;
digraphState = DIG_STATE_CODE_CHAR;
codeType = 10;
codeChars[codeCnt++] = key.getKeyChar();
logger.debug("decimal");
return DigraphResult.OK;
default:
switch (key.getKeyCode()) {
case KeyEvent.VK_TAB:
KeyStroke code = KeyStroke.getKeyStroke('\t');
digraphState = DIG_STATE_START;
return new DigraphResult(code);
default:
logger.debug("unknown");
digraphState = DIG_STATE_START;
return new DigraphResult(key);
}
}
case DIG_STATE_CODE_CHAR:
logger.debug("DIG_STATE_CODE_CHAR");
boolean valid = false;
switch (codeType) {
case 10:
if (key.getKeyChar() >= '0' && key.getKeyChar() <= '9') {
valid = true;
}
break;
case 8:
if (key.getKeyChar() >= '0' && key.getKeyChar() <= '7') {
valid = true;
}
break;
case 16:
if (key.getKeyChar() >= '0' && key.getKeyChar() <= '9'
|| key.getKeyChar() >= 'a' && key.getKeyChar() <= 'f'
|| key.getKeyChar() >= 'A' && key.getKeyChar() <= 'F') {
valid = true;
}
break;
}
if (valid) {
logger.debug("valid");
codeChars[codeCnt++] = key.getKeyChar();
if (codeCnt == codeMax) {
String digits = new String(codeChars, 0, codeCnt);
int val = Integer.parseInt(digits, codeType);
KeyStroke code = KeyStroke.getKeyStroke((char) val);
digraphState = DIG_STATE_START;
return new DigraphResult(code);
} else {
return DigraphResult.OK;
}
} else if (codeCnt > 0) {
logger.debug("invalid");
String digits = new String(codeChars, 0, codeCnt);
int val = Integer.parseInt(digits, codeType);
digraphState = DIG_STATE_START;
KeyStroke code = KeyStroke.getKeyStroke((char) val);
VimPlugin.getMacro().postKey(key, editor);
return new DigraphResult(code);
} else {
return DigraphResult.BAD;
}
default:
return DigraphResult.BAD;
}
}
public boolean processExEntry(@NotNull final Editor editor, @NotNull final DataContext context) {
ExEntryPanel panel = ExEntryPanel.getInstance();
panel.deactivate();
boolean res = true;
int flags = 0;
try {
CommandState.getInstance(editor).popState();
logger.debug("processing command");
final String text = panel.getText();
record(editor, text);
if (logger.isDebugEnabled()) logger.debug("swing=" + SwingUtilities.isEventDispatchThread());
if (panel.getLabel().equals(":")) {
flags = CommandParser.getInstance().processCommand(editor, context, text, 1);
if (logger.isDebugEnabled()) logger.debug("flags=" + flags);
if (CommandState.getInstance(editor).getMode() == CommandState.Mode.VISUAL) {
CommandGroups.getInstance().getMotion().exitVisual(editor, true);
}
} else {
int pos =
CommandGroups.getInstance()
.getSearch()
.search(
editor,
text,
panel.getCount(),
panel.getLabel().equals("/")
? Command.FLAG_SEARCH_FWD
: Command.FLAG_SEARCH_REV,
true);
if (pos == -1) {
res = false;
}
}
} catch (ExException ex) {
// VimPlugin.showMessage(ex.getMessage());
ProcessGroup.logger.info(ex.getMessage());
VimPlugin.indicateError();
res = false;
} catch (Exception bad) {
ProcessGroup.logger.error(bad);
VimPlugin.indicateError();
res = false;
} finally {
final int flg = flags;
final Project project = PlatformDataKeys.PROJECT.getData(context); // API change - don't merge
SwingUtilities.invokeLater(
new Runnable() {
public void run() {
// editor.getContentComponent().requestFocus();
// Reopening the file was the only way I could solve the focus problem introduced in
// IDEA at
// version 1050.
if (!ApplicationManager.getApplication().isUnitTestMode()
&& (flg & CommandParser.RES_DONT_REOPEN) == 0) {
VirtualFile vf = EditorData.getVirtualFile(editor);
if (vf != null) {
FileEditorManager.getInstance(project)
.openFile(EditorData.getVirtualFile(editor), true);
}
}
// If the result of the ex command is to display the "more" panel, show it here.
if ((flg & CommandParser.RES_MORE_PANEL) != 0
&& MorePanel.getInstance(editor).hasText()) {
RunnableHelper.runReadCommand(
project,
new Runnable() {
public void run() {
MorePanel.getInstance(editor).activate();
}
},
"ShowMorePanel",
"ExCommand");
}
}
});
}
return res;
}
public boolean execute(
@NotNull Editor editor, @NotNull DataContext context, @NotNull Command cmd) {
final Argument argument = cmd.getArgument();
return argument != null
&& VimPlugin.getChange().insertRegister(editor, context, argument.getCharacter());
}
protected boolean execute(
@NotNull Editor editor, @NotNull DataContext context, @NotNull Command cmd) {
return VimPlugin.getProcess().cancelExEntry(editor, context);
}
@Nullable
public TextRange getRange(
@NotNull Editor editor, DataContext context, int count, int rawCount, Argument argument) {
return VimPlugin.getMotion().getBlockQuoteRange(editor, '"', true);
}
public boolean searchAndReplace(
@NotNull Editor editor, @NotNull LineRange range, @NotNull String excmd, String exarg) {
boolean res = true;
// Explicitly exit visual mode here, so that visual mode marks don't change when we move the
// cursor to a match.
if (CommandState.getInstance(editor).getMode() == CommandState.Mode.VISUAL) {
VimPlugin.getMotion().exitVisual(editor);
}
CharPointer cmd = new CharPointer(new StringBuffer(exarg));
// sub_nsubs = 0;
// sub_nlines = 0;
int which_pat;
if (excmd.equals("~")) {
which_pat = RE_LAST; /* use last used regexp */
} else {
which_pat = RE_SUBST; /* use last substitute regexp */
}
CharPointer pat;
CharPointer sub;
char delimiter;
/* new pattern and substitution */
if (excmd.charAt(0) == 's'
&& !cmd.isNul()
&& !Character.isWhitespace(cmd.charAt())
&& "0123456789cegriIp|\"".indexOf(cmd.charAt()) == -1) {
/* don't accept alphanumeric for separator */
if (CharacterClasses.isAlpha(cmd.charAt())) {
VimPlugin.showMessage(MessageHelper.message(Msg.E146));
return false;
}
/*
* undocumented vi feature:
* "\/sub/" and "\?sub?" use last used search pattern (almost like
* //sub/r). "\&sub&" use last substitute pattern (like //sub/).
*/
if (cmd.charAt() == '\\') {
cmd.inc();
if ("/?&".indexOf(cmd.charAt()) == -1) {
VimPlugin.showMessage(MessageHelper.message(Msg.e_backslash));
return false;
}
if (cmd.charAt() != '&') {
which_pat = RE_SEARCH; /* use last '/' pattern */
}
pat = new CharPointer(""); /* empty search pattern */
delimiter = cmd.charAt(); /* remember delimiter character */
cmd.inc();
} else /* find the end of the regexp */ {
which_pat = RE_LAST; /* use last used regexp */
delimiter = cmd.charAt(); /* remember delimiter character */
cmd.inc();
pat = cmd.ref(0); /* remember start of search pat */
cmd = RegExp.skip_regexp(cmd, delimiter, true);
if (cmd.charAt() == delimiter) /* end delimiter found */ {
cmd.set('\u0000').inc(); /* replace it with a NUL */
}
}
/*
* Small incompatibility: vi sees '\n' as end of the command, but in
* Vim we want to use '\n' to find/substitute a NUL.
*/
sub = cmd.ref(0); /* remember the start of the substitution */
while (!cmd.isNul()) {
if (cmd.charAt() == delimiter) /* end delimiter found */ {
cmd.set('\u0000').inc(); /* replace it with a NUL */
break;
}
if (cmd.charAt(0) == '\\' && cmd.charAt(1) != 0) /* skip escaped characters */ {
cmd.inc();
}
cmd.inc();
}
} else /* use previous pattern and substitution */ {
if (lastReplace == null) /* there is no previous command */ {
VimPlugin.showMessage(MessageHelper.message(Msg.e_nopresub));
return false;
}
pat = null; /* search_regcomp() will use previous pattern */
sub = new CharPointer(lastReplace);
}
/*
* Find trailing options. When '&' is used, keep old options.
*/
if (cmd.charAt() == '&') {
cmd.inc();
} else {
do_all = Options.getInstance().isSet("gdefault");
do_ask = false;
do_error = true;
// do_print = false;
do_ic = 0;
}
while (!cmd.isNul()) {
/*
* Note that 'g' and 'c' are always inverted, also when p_ed is off.
* 'r' is never inverted.
*/
if (cmd.charAt() == 'g') {
do_all = !do_all;
} else if (cmd.charAt() == 'c') {
do_ask = !do_ask;
} else if (cmd.charAt() == 'e') {
do_error = !do_error;
} else if (cmd.charAt() == 'r') /* use last used regexp */ {
which_pat = RE_LAST;
} else if (cmd.charAt() == 'i') /* ignore case */ {
do_ic = 'i';
} else if (cmd.charAt() == 'I') /* don't ignore case */ {
do_ic = 'I';
} else if (cmd.charAt() != 'p') {
break;
}
cmd.inc();
}
int line1 = range.getStartLine();
int line2 = range.getEndLine();
/*
* check for a trailing count
*/
cmd = CharHelper.skipwhite(cmd);
if (CharacterClasses.isDigit(cmd.charAt())) {
int i = CharHelper.getdigits(cmd);
if (i <= 0 && do_error) {
VimPlugin.showMessage(MessageHelper.message(Msg.e_zerocount));
return false;
}
line1 = line2;
line2 = EditorHelper.normalizeLine(editor, line1 + i - 1);
}
/*
* check for trailing command or garbage
*/
cmd = CharHelper.skipwhite(cmd);
if (!cmd.isNul() && cmd.charAt() != '"') /* if not end-of-line or comment */ {
VimPlugin.showMessage(MessageHelper.message(Msg.e_trailing));
return false;
}
String pattern = "";
if (pat == null || pat.isNul()) {
switch (which_pat) {
case RE_LAST:
pattern = lastPattern;
break;
case RE_SEARCH:
pattern = lastSearch;
break;
case RE_SUBST:
pattern = lastSubstitute;
break;
}
} else {
pattern = pat.toString();
}
lastSubstitute = pattern;
if (pattern != null) {
setLastPattern(editor, pattern);
}
// int start = editor.logicalPositionToOffset(new LogicalPosition(line1, 0));
// int end = editor.logicalPositionToOffset(new LogicalPosition(line2,
// EditorHelper.getLineLength(editor, line2)));
int start = editor.getDocument().getLineStartOffset(line1);
int end = editor.getDocument().getLineEndOffset(line2);
RegExp sp;
RegExp.regmmatch_T regmatch = new RegExp.regmmatch_T();
sp = new RegExp();
regmatch.regprog = sp.vim_regcomp(pattern, 1);
if (regmatch.regprog == null) {
if (do_error) {
VimPlugin.showMessage(MessageHelper.message(Msg.e_invcmd));
}
return false;
}
/* the 'i' or 'I' flag overrules 'ignorecase' and 'smartcase' */
if (do_ic == 'i') {
regmatch.rmm_ic = true;
} else if (do_ic == 'I') {
regmatch.rmm_ic = false;
}
/*
* ~ in the substitute pattern is replaced with the old pattern.
* We do it here once to avoid it to be replaced over and over again.
* But don't do it when it starts with "\=", then it's an expression.
*/
if (!(sub.charAt(0) == '\\' && sub.charAt(1) == '=') && lastReplace != null) {
StringBuffer tmp = new StringBuffer(sub.toString());
int pos = 0;
while ((pos = tmp.indexOf("~", pos)) != -1) {
if (pos == 0 || tmp.charAt(pos - 1) != '\\') {
tmp.replace(pos, pos + 1, lastReplace);
pos += lastReplace.length();
}
pos++;
}
sub = new CharPointer(tmp);
}
lastReplace = sub.toString();
searchHighlight(false);
if (logger.isDebugEnabled()) {
logger.debug("search range=[" + start + "," + end + "]");
logger.debug("pattern=" + pattern + ", replace=" + sub);
}
int lastMatch = -1;
int lastLine = -1;
int searchcol = 0;
boolean firstMatch = true;
boolean got_quit = false;
int lcount = EditorHelper.getLineCount(editor);
for (int lnum = line1; lnum <= line2 && !got_quit; ) {
CharacterPosition newpos = null;
int nmatch = sp.vim_regexec_multi(regmatch, editor, lcount, lnum, searchcol);
if (nmatch > 0) {
if (firstMatch) {
VimPlugin.getMark().saveJumpLocation(editor);
firstMatch = false;
}
String match = sp.vim_regsub_multi(regmatch, lnum, sub, 1, false);
// logger.debug("found match[" + spos + "," + epos + "] - replace " + match);
int line = lnum + regmatch.startpos[0].lnum;
CharacterPosition startpos =
new CharacterPosition(lnum + regmatch.startpos[0].lnum, regmatch.startpos[0].col);
CharacterPosition endpos =
new CharacterPosition(lnum + regmatch.endpos[0].lnum, regmatch.endpos[0].col);
int startoff = EditorHelper.characterPositionToOffset(editor, startpos);
int endoff = EditorHelper.characterPositionToOffset(editor, endpos);
int newend = startoff + match.length();
if (do_all || line != lastLine) {
boolean doReplace = true;
if (do_ask) {
// editor.getSelectionModel().setSelection(startoff, endoff);
RangeHighlighter hl = highlightConfirm(editor, startoff, endoff);
int choice = getConfirmChoice(match);
// editor.getSelectionModel().removeSelection();
editor.getMarkupModel().removeHighlighter(hl);
switch (choice) {
case 0: // Yes
doReplace = true;
break;
case 1: // No
doReplace = false;
break;
case 2: // All
do_ask = false;
break;
case JOptionPane.CLOSED_OPTION:
case 3: // Quit
doReplace = false;
got_quit = true;
break;
case 4: // Last
do_all = false;
line2 = lnum;
doReplace = true;
break;
}
}
if (doReplace) {
editor.getDocument().replaceString(startoff, endoff, match);
lastMatch = startoff;
newpos = EditorHelper.offsetToCharacterPosition(editor, newend);
lnum += newpos.line - endpos.line;
line2 += newpos.line - endpos.line;
}
}
lastLine = line;
lnum += nmatch - 1;
if (do_all && startoff != endoff) {
if (newpos != null) {
lnum = newpos.line;
searchcol = newpos.column;
} else {
searchcol = endpos.column;
}
} else {
searchcol = 0;
lnum++;
}
} else {
lnum++;
searchcol = 0;
}
}
if (lastMatch != -1) {
MotionGroup.moveCaret(
editor,
VimPlugin.getMotion()
.moveCaretToLineStartSkipLeading(
editor, editor.offsetToLogicalPosition(lastMatch).line));
} else {
VimPlugin.showMessage(MessageHelper.message(Msg.e_patnotf2, pattern));
}
return res;
}
protected boolean execute(
@NotNull Editor editor, @NotNull DataContext context, @NotNull Command cmd) {
return VimPlugin.getMotion().scrollColumnToLastScreenColumn(editor);
}
@Nullable
private TextRange findIt(
@NotNull Editor editor,
int startOffset,
int count,
int dir,
boolean noSmartCase,
boolean wrap,
boolean showMessages,
boolean wholeFile) {
TextRange res = null;
if (lastSearch == null || lastSearch.length() == 0) {
return res;
}
/*
int pflags = RE.REG_MULTILINE;
if (shouldIgnoreCase(lastSearch, noSmartCase))
{
pflags |= RE.REG_ICASE;
}
*/
// RE sp;
RegExp sp;
RegExp.regmmatch_T regmatch = new RegExp.regmmatch_T();
regmatch.rmm_ic = shouldIgnoreCase(lastSearch, noSmartCase);
sp = new RegExp();
regmatch.regprog = sp.vim_regcomp(lastSearch, 1);
if (regmatch == null) {
if (logger.isDebugEnabled()) logger.debug("bad pattern: " + lastSearch);
return res;
}
/*
int extra_col = 1;
int startcol = -1;
boolean found = false;
boolean match_ok = true;
LogicalPosition pos = editor.offsetToLogicalPosition(startOffset);
LogicalPosition endpos = null;
//REMatch match = null;
*/
CharacterPosition lpos = EditorHelper.offsetToCharacterPosition(editor, startOffset);
RegExp.lpos_T pos = new RegExp.lpos_T();
pos.lnum = lpos.line;
pos.col = lpos.column;
int found;
int lnum; /* no init to shut up Apollo cc */
// RegExp.regmmatch_T regmatch;
CharPointer ptr;
int matchcol;
int startcol;
RegExp.lpos_T endpos = new RegExp.lpos_T();
int loop;
RegExp.lpos_T start_pos;
boolean at_first_line;
int extra_col = 1;
boolean match_ok;
long nmatched;
// int submatch = 0;
int first_lnum;
int lineCount = EditorHelper.getLineCount(editor);
int startLine = 0;
int endLine = lineCount;
do /* loop for count */ {
start_pos = new RegExp.lpos_T(pos); /* remember start pos for detecting no match */
found = 0; /* default: not found */
at_first_line = true; /* default: start in first line */
if (pos.lnum == -1) /* correct lnum for when starting in line 0 */ {
pos.lnum = 0;
pos.col = 0;
at_first_line = false; /* not in first line now */
}
/*
* Start searching in current line, unless searching backwards and
* we're in column 0.
*/
if (dir == -1 && start_pos.col == 0) {
lnum = pos.lnum - 1;
at_first_line = false;
} else {
lnum = pos.lnum;
}
int lcount = EditorHelper.getLineCount(editor);
for (loop = 0; loop <= 1; ++loop) /* loop twice if 'wrapscan' set */ {
if (!wholeFile) {
startLine = lnum;
endLine = lnum + 1;
}
for (; lnum >= startLine && lnum < endLine; lnum += dir, at_first_line = false) {
/*
* Look for a match somewhere in the line.
*/
first_lnum = lnum;
nmatched = sp.vim_regexec_multi(regmatch, editor, lcount, lnum, 0);
if (nmatched > 0) {
/* match may actually be in another line when using \zs */
lnum += regmatch.startpos[0].lnum;
ptr = new CharPointer(EditorHelper.getLineBuffer(editor, lnum));
startcol = regmatch.startpos[0].col;
endpos = regmatch.endpos[0];
/*
* Forward search in the first line: match should be after
* the start position. If not, continue at the end of the
* match (this is vi compatible) or on the next char.
*/
if (dir == 1 && at_first_line) {
match_ok = true;
/*
* When match lands on a NUL the cursor will be put
* one back afterwards, compare with that position,
* otherwise "/$" will get stuck on end of line.
*/
while ((startcol - (startcol == ptr.strlen() ? 1 : 0))
< (start_pos.col + extra_col)) {
if (nmatched > 1) {
/* end is in next line, thus no match in
* this line */
match_ok = false;
break;
}
matchcol = endpos.col;
/* for empty match: advance one char */
if (matchcol == startcol && ptr.charAt(matchcol) != '\u0000') {
++matchcol;
}
if (ptr.charAt(matchcol) == '\u0000'
|| (nmatched = sp.vim_regexec_multi(regmatch, editor, lcount, lnum, matchcol))
== 0) {
match_ok = false;
break;
}
startcol = regmatch.startpos[0].col;
endpos = regmatch.endpos[0];
/* Need to get the line pointer again, a
* multi-line search may have made it invalid. */
ptr = new CharPointer(EditorHelper.getLineBuffer(editor, lnum));
}
if (!match_ok) {
continue;
}
}
if (dir == -1) {
/*
* Now, if there are multiple matches on this line,
* we have to get the last one. Or the last one before
* the cursor, if we're on that line.
* When putting the new cursor at the end, compare
* relative to the end of the match.
*/
match_ok = false;
for (; ; ) {
if (!at_first_line || (regmatch.startpos[0].col + extra_col <= start_pos.col)) {
/* Remember this position, we use it if it's
* the last match in the line. */
match_ok = true;
startcol = regmatch.startpos[0].col;
endpos = regmatch.endpos[0];
} else {
break;
}
/*
* We found a valid match, now check if there is
* another one after it.
* If vi-compatible searching, continue at the end
* of the match, otherwise continue one position
* forward.
*/
if (nmatched > 1) {
break;
}
matchcol = endpos.col;
/* for empty match: advance one char */
if (matchcol == startcol && ptr.charAt(matchcol) != '\u0000') {
++matchcol;
}
if (ptr.charAt(matchcol) == '\u0000'
|| (nmatched = sp.vim_regexec_multi(regmatch, editor, lcount, lnum, matchcol))
== 0) {
break;
}
/* Need to get the line pointer again, a
* multi-line search may have made it invalid. */
ptr = new CharPointer(EditorHelper.getLineBuffer(editor, lnum));
}
/*
* If there is only a match after the cursor, skip
* this match.
*/
if (!match_ok) {
continue;
}
}
pos.lnum = lnum;
pos.col = startcol;
endpos.lnum += first_lnum;
found = 1;
/* Set variables used for 'incsearch' highlighting. */
// search_match_lines = endpos.lnum - (lnum - first_lnum);
// search_match_endcol = endpos.col;
break;
}
// line_breakcheck(); /* stop if ctrl-C typed */
// if (got_int)
// break;
if (loop != 0 && lnum == start_pos.lnum) {
break; /* if second loop, stop where started */
}
}
at_first_line = false;
/*
* stop the search if wrapscan isn't set, after an interrupt and
* after a match
*/
if (!wrap || found != 0) {
break;
}
/*
* If 'wrapscan' is set we continue at the other end of the file.
* If 'shortmess' does not contain 's', we give a message.
* This message is also remembered in keep_msg for when the screen
* is redrawn. The keep_msg is cleared whenever another message is
* written.
*/
if (dir == -1) /* start second loop at the other end */ {
lnum = lineCount - 1;
// if (!shortmess(SHM_SEARCH) && (options & SEARCH_MSG))
// give_warning((char_u *)_(top_bot_msg), TRUE);
} else {
lnum = 0;
// if (!shortmess(SHM_SEARCH) && (options & SEARCH_MSG))
// give_warning((char_u *)_(bot_top_msg), TRUE);
}
}
// if (got_int || called_emsg || break_loop)
// break;
} while (--count > 0 && found != 0); /* stop after count matches or no match */
if (found == 0) /* did not find it */ {
// if ((options & SEARCH_MSG) == SEARCH_MSG)
if (showMessages) {
if (wrap) {
VimPlugin.showMessage(MessageHelper.message(Msg.e_patnotf2, lastSearch));
} else if (lnum <= 0) {
VimPlugin.showMessage(MessageHelper.message(Msg.E384, lastSearch));
} else {
VimPlugin.showMessage(MessageHelper.message(Msg.E385, lastSearch));
}
}
return null;
}
// return new TextRange(editor.logicalPositionToOffset(new LogicalPosition(pos.lnum, pos.col)),
// editor.logicalPositionToOffset(new LogicalPosition(endpos.lnum, endpos.col)));
// return new TextRange(editor.logicalPositionToOffset(new LogicalPosition(pos.lnum, 0)) +
// pos.col,
// editor.logicalPositionToOffset(new LogicalPosition(endpos.lnum, 0)) + endpos.col);
return new TextRange(
EditorHelper.characterPositionToOffset(editor, new CharacterPosition(pos.lnum, pos.col)),
EditorHelper.characterPositionToOffset(
editor, new CharacterPosition(endpos.lnum, endpos.col)));
}
public int getOffset(
@NotNull Editor editor, DataContext context, int count, int rawCount, Argument argument) {
return VimPlugin.getMotion().moveCaretToMiddleScreenLine(editor);
}
public void selectionChanged(@NotNull FileEditorManagerEvent event) {
VimPlugin.getSearch().updateHighlight();
}