chylex/IntelliJ-IdeaVim
1
0
Fork 0
mirror of https://github.com/chylex/IntelliJ-IdeaVim.git synced 2025-03-07 03:32:51 +01:00
Code

Move action settings to handler

Browse Source
This commit is contained in:
Alex Plate 2019-08-30 18:10:14 +03:00
parent 256f5fcd0e
commit fb007b8835
No known key found for this signature in database
GPG Key ID: 0B97153C8FFEC09F
279 changed files with 5519 additions and 5098 deletions
src/com/maddyhome/idea/vim/action
ExEntryAction.javaResetModeAction.javaVimCommands.ktVimShortcutKeyAction.java
change
OperatorAction.javaRedoAction.javaRepeatChangeAction.javaRepeatExCommandAction.javaUndoAction.java
change
AutoIndentLinesVisualAction.javaChangeCaseLowerMotionAction.javaChangeCaseLowerVisualAction.javaChangeCaseToggleCharacterAction.javaChangeCaseToggleMotionAction.javaChangeCaseToggleVisualAction.javaChangeCaseUpperMotionAction.javaChangeCaseUpperVisualAction.javaChangeCharacterAction.javaChangeCharactersAction.javaChangeEndOfLineAction.javaChangeLastGlobalSearchReplaceAction.javaChangeLastSearchReplaceAction.javaChangeLineAction.javaChangeMotionAction.javaChangeReplaceAction.javaChangeVisualAction.javaChangeVisualCharacterAction.javaChangeVisualLinesAction.javaChangeVisualLinesEndAction.javaFilterCountLinesAction.javaFilterMotionAction.javaFilterVisualLinesAction.javaReformatCodeVisualAction.java
number
ChangeNumberDecAction.javaChangeNumberIncAction.javaChangeVisualNumberAvalancheDecAction.javaChangeVisualNumberAvalancheIncAction.javaChangeVisualNumberDecAction.javaChangeVisualNumberIncAction.java
delete
DeleteCharacterAction.javaDeleteCharacterLeftAction.javaDeleteCharacterRightAction.javaDeleteEndOfLineAction.javaDeleteJoinLinesAction.javaDeleteJoinLinesSpacesAction.javaDeleteJoinVisualLinesAction.javaDeleteJoinVisualLinesSpacesAction.javaDeleteLineAction.javaDeleteMotionAction.javaDeleteVisualAction.javaDeleteVisualLinesAction.javaDeleteVisualLinesEndAction.java
insert
InsertAfterCursorAction.javaInsertAfterLineEndAction.javaInsertAtPreviousInsertAction.javaInsertBeforeCursorAction.javaInsertBeforeFirstNonBlankAction.javaInsertCharacterAboveCursorAction.javaInsertCharacterBelowCursorAction.javaInsertDeleteInsertedTextAction.javaInsertDeletePreviousWordAction.javaInsertEnterAction.javaInsertExitModeAction.javaInsertInsertAction.javaInsertLineStartAction.javaInsertNewLineAboveAction.javaInsertNewLineBelowAction.javaInsertPreviousInsertAction.javaInsertPreviousInsertExitAction.javaInsertRegisterAction.javaInsertSingleCommandAction.javaVisualBlockAppendAction.javaVisualBlockInsertAction.java
shift
AutoIndentLinesAction.javaAutoIndentMotionAction.javaShiftLeftLinesAction.ktShiftLeftMotionAction.javaShiftLeftVisualAction.javaShiftRightLinesAction.ktShiftRightMotionAction.javaShiftRightVisualAction.java
copy
PutTextAfterCursorAction.javaPutTextAfterCursorActionMoveCursor.javaPutTextAfterCursorNoIndentAction.javaPutTextBeforeCursorAction.javaPutTextBeforeCursorActionMoveCursor.javaPutTextBeforeCursorNoIndentAction.javaPutVisualTextAction.ktPutVisualTextMoveCursorAction.ktPutVisualTextNoIndentAction.ktSelectRegisterAction.javaYankLineAction.ktYankMotionAction.javaYankVisualAction.javaYankVisualLinesAction.java
editor
VimEditorActions.kt
ex
ProcessExEntryAction.java
file
FileGetAsciiAction.javaFileGetFileInfoAction.javaFileGetHexAction.java
Show More

36
src/com/maddyhome/idea/vim/action/ExEntryAction.java
View File

@ -32,28 +32,28 @@ import java.util.Set;
public class ExEntryAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.NVO;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet(":");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_READONLY;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new VimActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.NVO;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet(":");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_READONLY;
}
@Override
public boolean execute(@NotNull Editor editor, @NotNull DataContext context, @NotNull Command cmd) {
VimPlugin.getProcess().startExCommand(editor, context, cmd);

36
src/com/maddyhome/idea/vim/action/ResetModeAction.java
View File

@ -37,6 +37,24 @@ public class ResetModeAction extends VimCommandAction {
@Override
protected VimActionHandler makeActionHandler() {
return new VimActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.NO;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-\\><C-N>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.RESET;
}
@Override
public boolean execute(@NotNull Editor editor, @NotNull DataContext context, @NotNull Command cmd) {
KeyHandler.getInstance().fullReset(HelperKt.getTopLevelEditor(editor));
@ -44,22 +62,4 @@ public class ResetModeAction extends VimCommandAction {
}
};
}
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.NO;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-\\><C-N>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.RESET;
}
}

39
src/com/maddyhome/idea/vim/action/VimCommands.kt
View File

@ -22,19 +22,13 @@ import com.google.common.collect.ImmutableSet
import com.intellij.openapi.actionSystem.DataContext
import com.intellij.openapi.editor.Caret
import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.KeyHandler
import com.maddyhome.idea.vim.command.Argument
import com.maddyhome.idea.vim.command.Command
import com.maddyhome.idea.vim.command.CommandFlags
import com.maddyhome.idea.vim.command.MappingMode
import com.maddyhome.idea.vim.common.TextRange
import com.maddyhome.idea.vim.handler.EditorActionHandlerBase
import com.maddyhome.idea.vim.handler.MotionActionHandler
import com.maddyhome.idea.vim.handler.TextObjectActionHandler
import com.maddyhome.idea.vim.handler.VimActionHandler
import com.maddyhome.idea.vim.helper.StringHelper
import com.maddyhome.idea.vim.helper.noneOfEnum
import java.util.*
import javax.swing.KeyStroke
/**
@ -69,23 +63,6 @@ sealed class VimCommandActionBase {
protected abstract fun makeActionHandler(): EditorActionHandlerBase
abstract val mappingModes: Set<MappingMode>
abstract val keyStrokesSet: Set<List<KeyStroke>>
abstract val type: Command.Type
open val argumentType: Argument.Type = Argument.Type.NONE
/**
* Returns various binary flags for the command.
*
* These legacy flags will be refactored in future releases.
*
* @see com.maddyhome.idea.vim.command.Command
*/
open val flags: EnumSet<CommandFlags> = noneOfEnum()
protected companion object {
@JvmStatic
fun parseKeysSet(vararg keyStrings: String): Set<List<KeyStroke>> {
@ -111,8 +88,6 @@ abstract class TextObjectAction : VimCommandActionBase() {
return actionHandler.getRange(editor, caret, context, count, rawCount, argument)
}
final override val type: Command.Type = Command.Type.MOTION
}
abstract class MotionEditorAction : VimCommandActionBase() {
@ -132,18 +107,4 @@ abstract class MotionEditorAction : VimCommandActionBase() {
is MotionActionHandler.ForEachCaret -> actionHandler.getOffset(editor, caret, context, count, rawCount, argument)
}
}
final override val type: Command.Type = Command.Type.MOTION
}
abstract class NativeAction : VimCommandAction() {
abstract val actionName: String
final override fun makeActionHandler(): VimActionHandler = object : VimActionHandler.SingleExecution() {
override fun execute(editor: Editor, context: DataContext, cmd: Command): Boolean {
KeyHandler.executeAction(actionName, context)
return true
}
}
}

4
src/com/maddyhome/idea/vim/action/VimShortcutKeyAction.java
View File

@ -180,7 +180,7 @@ public class VimShortcutKeyAction extends AnAction implements DumbAware {
return values.stream().anyMatch(actionId -> {
final VimCommandActionBase action = RegisterActions.findAction(actionId);
if (action == null) return false;
return action.getKeyStrokesSet().stream()
return action.getHandler().getKeyStrokesSet().stream()
.anyMatch(ks -> !ks.isEmpty() && ks.get(0).equals(keyStroke));
});
}
@ -203,7 +203,7 @@ public class VimShortcutKeyAction extends AnAction implements DumbAware {
}
private boolean isEnabledForLookup(@NotNull KeyStroke keyStroke) {
for (List<KeyStroke> keys : InsertExitModeAction.getInstance().getKeyStrokesSet()) {
for (List<KeyStroke> keys : InsertExitModeAction.getInstance().getHandler().getKeyStrokesSet()) {
// XXX: Currently we cannot handle <C-\><C-N> because of the importance of <C-N> for the IDE on Linux
if (keys.size() == 1 && keyStroke.equals(keys.get(0))) {
return true;

64
src/com/maddyhome/idea/vim/action/change/OperatorAction.java
View File

@ -46,6 +46,38 @@ final public class OperatorAction extends VimCommandAction {
@Override
final protected VimActionHandler makeActionHandler() {
return new VimActionHandler.SingleExecution() {
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("g@");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.OTHER_SELF_SYNCHRONIZED;
}
@Contract(pure = true)
@NotNull
@Override
final public Argument.Type getArgumentType() {
return Argument.Type.MOTION;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_OP_PEND);
}
@Override
public boolean execute(@NotNull Editor editor, @NotNull DataContext context, @NotNull Command cmd) {
final OperatorFunction operatorFunction = VimPlugin.getKey().getOperatorFunction();
@ -73,36 +105,4 @@ final public class OperatorAction extends VimCommandAction {
};
}
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("g@");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.OTHER_SELF_SYNCHRONIZED;
}
@Contract(pure = true)
@NotNull
@Override
final public Argument.Type getArgumentType() {
return Argument.Type.MOTION;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_OP_PEND);
}
}

36
src/com/maddyhome/idea/vim/action/change/RedoAction.java
View File

@ -33,28 +33,28 @@ import java.util.Set;
public class RedoAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-R>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_SELF_SYNCHRONIZED;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new VimActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-R>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_SELF_SYNCHRONIZED;
}
@Override
public boolean execute(@NotNull Editor editor, @NotNull DataContext context, @NotNull Command cmd) {
return UndoRedoHelper.INSTANCE.redo(context);

36
src/com/maddyhome/idea/vim/action/change/RepeatChangeAction.java
View File

@ -36,28 +36,28 @@ import java.util.Set;
public class RepeatChangeAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet(".");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_WRITABLE;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new VimActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet(".");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_WRITABLE;
}
@Override
public boolean execute(@NotNull Editor editor, @NotNull DataContext context, @NotNull Command command) {
CommandState state = CommandState.getInstance(editor);

36
src/com/maddyhome/idea/vim/action/change/RepeatExCommandAction.java
View File

@ -34,28 +34,28 @@ import java.util.Set;
public class RepeatExCommandAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("@:");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_SELF_SYNCHRONIZED;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new VimActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("@:");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_SELF_SYNCHRONIZED;
}
@Override
public boolean execute(@NotNull Editor editor, @NotNull DataContext context, @NotNull Command command) {
int count = command.getCount();

36
src/com/maddyhome/idea/vim/action/change/UndoAction.java
View File

@ -33,28 +33,28 @@ import java.util.Set;
public class UndoAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("u", "<Undo>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_SELF_SYNCHRONIZED;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new VimActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("u", "<Undo>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_SELF_SYNCHRONIZED;
}
@Override
public boolean execute(@NotNull Editor editor, @NotNull DataContext context, @NotNull Command cmd) {
return UndoRedoHelper.INSTANCE.undo(context);

60
src/com/maddyhome/idea/vim/action/change/change/AutoIndentLinesVisualAction.java
View File

@ -46,41 +46,41 @@ final public class AutoIndentLinesVisualAction extends VimCommandAction {
@Override
final protected VimActionHandler makeActionHandler() {
return new VisualOperatorActionHandler.ForEachCaret() {
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("=");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MOT_LINEWISE, CommandFlags.FLAG_EXIT_VISUAL);
}
@Override
public boolean executeAction(@NotNull Editor editor,
@NotNull Caret caret,
@NotNull DataContext context,
@NotNull Command cmd,
@NotNull VimSelection range) {
@NotNull Caret caret,
@NotNull DataContext context,
@NotNull Command cmd,
@NotNull VimSelection range) {
VimPlugin.getChange().autoIndentRange(editor, caret, context, range.toVimTextRange(true));
return true;
}
};
}
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("=");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MOT_LINEWISE, CommandFlags.FLAG_EXIT_VISUAL);
}
}

60
src/com/maddyhome/idea/vim/action/change/change/ChangeCaseLowerMotionAction.java
View File

@ -40,40 +40,40 @@ import java.util.Set;
public class ChangeCaseLowerMotionAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("gu");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_OP_PEND);
}
@NotNull
@Override
public Argument.Type getArgumentType() {
return Argument.Type.MOTION;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.ForEachCaret() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("gu");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_OP_PEND);
}
@NotNull
@Override
public Argument.Type getArgumentType() {
return Argument.Type.MOTION;
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull Caret caret,

60
src/com/maddyhome/idea/vim/action/change/change/ChangeCaseLowerVisualAction.java
View File

@ -48,42 +48,42 @@ final public class ChangeCaseLowerVisualAction extends VimCommandAction {
@Override
final protected VimActionHandler makeActionHandler() {
return new VisualOperatorActionHandler.ForEachCaret() {
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("u");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_EXIT_VISUAL);
}
@Override
public boolean executeAction(@NotNull Editor editor,
@NotNull Caret caret,
@NotNull DataContext context,
@NotNull Command cmd,
@NotNull VimSelection range) {
@NotNull Caret caret,
@NotNull DataContext context,
@NotNull Command cmd,
@NotNull VimSelection range) {
final Editor topLevelEditor = HelperKt.getTopLevelEditor(editor);
return VimPlugin.getChange()
.changeCaseRange(topLevelEditor, caret, range.toVimTextRange(false), CharacterHelper.CASE_LOWER);
}
};
}
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("u");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_EXIT_VISUAL);
}
}

36
src/com/maddyhome/idea/vim/action/change/change/ChangeCaseToggleCharacterAction.java
View File

@ -37,28 +37,28 @@ import java.util.Set;
public class ChangeCaseToggleCharacterAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("~");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.ForEachCaret() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("~");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull Caret caret,

60
src/com/maddyhome/idea/vim/action/change/change/ChangeCaseToggleMotionAction.java
View File

@ -40,40 +40,40 @@ import java.util.Set;
public class ChangeCaseToggleMotionAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("g~");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
public Argument.Type getArgumentType() {
return Argument.Type.MOTION;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_OP_PEND);
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.ForEachCaret() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("g~");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
public Argument.Type getArgumentType() {
return Argument.Type.MOTION;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_OP_PEND);
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull Caret caret,

51
src/com/maddyhome/idea/vim/action/change/change/ChangeCaseToggleVisualAction.java
View File

@ -47,6 +47,31 @@ final public class ChangeCaseToggleVisualAction extends VimCommandAction {
@Override
final protected VimActionHandler makeActionHandler() {
return new VisualOperatorActionHandler.ForEachCaret() {
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("~");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_EXIT_VISUAL);
}
@Override
public boolean executeAction(@NotNull Editor editor,
@NotNull Caret caret,
@ -58,30 +83,4 @@ final public class ChangeCaseToggleVisualAction extends VimCommandAction {
}
};
}
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("~");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_EXIT_VISUAL);
}
}

60
src/com/maddyhome/idea/vim/action/change/change/ChangeCaseUpperMotionAction.java
View File

@ -40,40 +40,40 @@ import java.util.Set;
public class ChangeCaseUpperMotionAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("gU");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
public Argument.Type getArgumentType() {
return Argument.Type.MOTION;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_OP_PEND);
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.ForEachCaret() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("gU");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
public Argument.Type getArgumentType() {
return Argument.Type.MOTION;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_OP_PEND);
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull Caret caret,

51
src/com/maddyhome/idea/vim/action/change/change/ChangeCaseUpperVisualAction.java
View File

@ -47,6 +47,31 @@ final public class ChangeCaseUpperVisualAction extends VimCommandAction {
@Override
final protected VimActionHandler makeActionHandler() {
return new VisualOperatorActionHandler.ForEachCaret() {
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("U");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_EXIT_VISUAL);
}
@Override
public boolean executeAction(@NotNull Editor editor,
@NotNull Caret caret,
@ -58,30 +83,4 @@ final public class ChangeCaseUpperVisualAction extends VimCommandAction {
}
};
}
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("U");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_EXIT_VISUAL);
}
}

60
src/com/maddyhome/idea/vim/action/change/change/ChangeCharacterAction.java
View File

@ -39,40 +39,40 @@ import java.util.Set;
public class ChangeCharacterAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("r");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
public Argument.Type getArgumentType() {
return Argument.Type.DIGRAPH;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_ALLOW_DIGRAPH);
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.ForEachCaret() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("r");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
public Argument.Type getArgumentType() {
return Argument.Type.DIGRAPH;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_ALLOW_DIGRAPH);
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull Caret caret,

48
src/com/maddyhome/idea/vim/action/change/change/ChangeCharactersAction.java
View File

@ -39,34 +39,34 @@ import java.util.Set;
public class ChangeCharactersAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("s");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_NO_REPEAT, CommandFlags.FLAG_MULTIKEY_UNDO);
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.ForEachCaret() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("s");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_NO_REPEAT, CommandFlags.FLAG_MULTIKEY_UNDO);
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull Caret caret,

48
src/com/maddyhome/idea/vim/action/change/change/ChangeEndOfLineAction.java
View File

@ -39,34 +39,34 @@ import java.util.Set;
public class ChangeEndOfLineAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("C");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_NO_REPEAT, CommandFlags.FLAG_MULTIKEY_UNDO);
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.ForEachCaret() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("C");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_NO_REPEAT, CommandFlags.FLAG_MULTIKEY_UNDO);
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull Caret caret,

36
src/com/maddyhome/idea/vim/action/change/change/ChangeLastGlobalSearchReplaceAction.java
View File

@ -38,28 +38,28 @@ import java.util.Set;
public class ChangeLastGlobalSearchReplaceAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("g&");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_SELF_SYNCHRONIZED;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("g&");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_SELF_SYNCHRONIZED;
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull DataContext context,

36
src/com/maddyhome/idea/vim/action/change/change/ChangeLastSearchReplaceAction.java
View File

@ -38,28 +38,28 @@ import java.util.Set;
public class ChangeLastSearchReplaceAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("&");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_SELF_SYNCHRONIZED;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("&");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_SELF_SYNCHRONIZED;
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull DataContext context,

48
src/com/maddyhome/idea/vim/action/change/change/ChangeLineAction.java
View File

@ -39,34 +39,34 @@ import java.util.Set;
public class ChangeLineAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("cc", "S");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_NO_REPEAT, CommandFlags.FLAG_ALLOW_MID_COUNT, CommandFlags.FLAG_MULTIKEY_UNDO);
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.ForEachCaret() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("cc", "S");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_NO_REPEAT, CommandFlags.FLAG_ALLOW_MID_COUNT, CommandFlags.FLAG_MULTIKEY_UNDO);
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull Caret caret,

60
src/com/maddyhome/idea/vim/action/change/change/ChangeMotionAction.java
View File

@ -39,40 +39,40 @@ import java.util.Set;
public class ChangeMotionAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("c");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_OP_PEND, CommandFlags.FLAG_MULTIKEY_UNDO);
}
@NotNull
@Override
public Argument.Type getArgumentType() {
return Argument.Type.MOTION;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.ForEachCaret() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("c");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_OP_PEND, CommandFlags.FLAG_MULTIKEY_UNDO);
}
@NotNull
@Override
public Argument.Type getArgumentType() {
return Argument.Type.MOTION;
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull Caret caret,

48
src/com/maddyhome/idea/vim/action/change/change/ChangeReplaceAction.java
View File

@ -38,34 +38,34 @@ import java.util.Set;
public class ChangeReplaceAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("R");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MULTIKEY_UNDO);
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("R");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MULTIKEY_UNDO);
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull DataContext context,

60
src/com/maddyhome/idea/vim/action/change/change/ChangeVisualAction.java
View File

@ -46,41 +46,41 @@ final public class ChangeVisualAction extends VimCommandAction {
@Override
final protected VimActionHandler makeActionHandler() {
return new VisualOperatorActionHandler.ForEachCaret() {
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("c", "s");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MULTIKEY_UNDO, CommandFlags.FLAG_EXIT_VISUAL);
}
@Override
public boolean executeAction(@NotNull Editor editor,
@NotNull Caret caret,
@NotNull DataContext context,
@NotNull Command cmd,
@NotNull VimSelection range) {
@NotNull Caret caret,
@NotNull DataContext context,
@NotNull Command cmd,
@NotNull VimSelection range) {
return VimPlugin.getChange().changeRange(editor, caret, range.toVimTextRange(false), range.getType(), context);
}
};
}
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("c", "s");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MULTIKEY_UNDO, CommandFlags.FLAG_EXIT_VISUAL);
}
}

74
src/com/maddyhome/idea/vim/action/change/change/ChangeVisualCharacterAction.java
View File

@ -47,49 +47,49 @@ final public class ChangeVisualCharacterAction extends VimCommandAction {
@Override
final protected VimActionHandler makeActionHandler() {
return new VisualOperatorActionHandler.ForEachCaret() {
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("r");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@Contract(pure = true)
@NotNull
@Override
final public Argument.Type getArgumentType() {
return Argument.Type.DIGRAPH;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_ALLOW_DIGRAPH, CommandFlags.FLAG_EXIT_VISUAL);
}
@Override
public boolean executeAction(@NotNull Editor editor,
@NotNull Caret caret,
@NotNull DataContext context,
@NotNull Command cmd,
@NotNull VimSelection range) {
@NotNull Caret caret,
@NotNull DataContext context,
@NotNull Command cmd,
@NotNull VimSelection range) {
final Argument argument = cmd.getArgument();
return argument != null &&
VimPlugin.getChange().changeCharacterRange(editor, range.toVimTextRange(false), argument.getCharacter());
}
};
}
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("r");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@Contract(pure = true)
@NotNull
@Override
final public Argument.Type getArgumentType() {
return Argument.Type.DIGRAPH;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_ALLOW_DIGRAPH, CommandFlags.FLAG_EXIT_VISUAL);
}
}

66
src/com/maddyhome/idea/vim/action/change/change/ChangeVisualLinesAction.java
View File

@ -49,44 +49,46 @@ final public class ChangeVisualLinesAction extends VimCommandAction {
@Override
final protected VimActionHandler makeActionHandler() {
return new VisualOperatorActionHandler.ForEachCaret() {
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("R", "S");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet
.of(CommandFlags.FLAG_MOT_LINEWISE, CommandFlags.FLAG_MULTIKEY_UNDO, CommandFlags.FLAG_EXIT_VISUAL);
}
@Override
public boolean executeAction(@NotNull Editor editor,
@NotNull Caret caret,
@NotNull DataContext context,
@NotNull Command cmd,
@NotNull VimSelection range) {
@NotNull Caret caret,
@NotNull DataContext context,
@NotNull Command cmd,
@NotNull VimSelection range) {
final TextRange textRange = range.toVimTextRange(true);
final TextRange lineRange = new TextRange(EditorHelper.getLineStartForOffset(editor, textRange.getStartOffset()),
EditorHelper.getLineEndForOffset(editor, textRange.getEndOffset()) + 1);
final TextRange lineRange =
new TextRange(EditorHelper.getLineStartForOffset(editor, textRange.getStartOffset()),
EditorHelper.getLineEndForOffset(editor, textRange.getEndOffset()) + 1);
return VimPlugin.getChange().changeRange(editor, caret, lineRange, SelectionType.LINE_WISE, context);
}
};
}
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("R", "S");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MOT_LINEWISE, CommandFlags.FLAG_MULTIKEY_UNDO, CommandFlags.FLAG_EXIT_VISUAL);
}
}

66
src/com/maddyhome/idea/vim/action/change/change/ChangeVisualLinesEndAction.java
View File

@ -49,12 +49,39 @@ final public class ChangeVisualLinesEndAction extends VimCommandAction {
@Override
final protected VimActionHandler makeActionHandler() {
return new VisualOperatorActionHandler.ForEachCaret() {
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("C");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet
.of(CommandFlags.FLAG_MOT_LINEWISE, CommandFlags.FLAG_MULTIKEY_UNDO, CommandFlags.FLAG_EXIT_VISUAL);
}
@Override
public boolean executeAction(@NotNull Editor editor,
@NotNull Caret caret,
@NotNull DataContext context,
@NotNull Command cmd,
@NotNull VimSelection range) {
@NotNull Caret caret,
@NotNull DataContext context,
@NotNull Command cmd,
@NotNull VimSelection range) {
TextRange vimTextRange = range.toVimTextRange(true);
if (range.getType() == SelectionType.BLOCK_WISE && vimTextRange.isMultiple()) {
final int[] starts = vimTextRange.getStartOffsets();
@ -68,37 +95,12 @@ final public class ChangeVisualLinesEndAction extends VimCommandAction {
return VimPlugin.getChange().changeRange(editor, caret, blockRange, SelectionType.BLOCK_WISE, context);
}
else {
final TextRange lineRange = new TextRange(EditorHelper.getLineStartForOffset(editor, vimTextRange.getStartOffset()),
EditorHelper.getLineEndForOffset(editor, vimTextRange.getEndOffset()) + 1);
final TextRange lineRange =
new TextRange(EditorHelper.getLineStartForOffset(editor, vimTextRange.getStartOffset()),
EditorHelper.getLineEndForOffset(editor, vimTextRange.getEndOffset()) + 1);
return VimPlugin.getChange().changeRange(editor, caret, lineRange, SelectionType.LINE_WISE, context);
}
}
};
}
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("C");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MOT_LINEWISE, CommandFlags.FLAG_MULTIKEY_UNDO, CommandFlags.FLAG_EXIT_VISUAL);
}
}

36
src/com/maddyhome/idea/vim/action/change/change/FilterCountLinesAction.java
View File

@ -33,28 +33,28 @@ import java.util.Set;
public class FilterCountLinesAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("!!");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new VimActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("!!");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@Override
public boolean execute(@NotNull Editor editor, @NotNull DataContext context, @NotNull Command cmd) {
VimPlugin.getProcess().startFilterCommand(editor, context, cmd);

99
src/com/maddyhome/idea/vim/action/change/change/FilterMotionAction.java
View File

@ -40,40 +40,40 @@ import java.util.Set;
public class FilterMotionAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("!");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
public Argument.Type getArgumentType() {
return Argument.Type.MOTION;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_OP_PEND);
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new VimActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("!");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
public Argument.Type getArgumentType() {
return Argument.Type.MOTION;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_OP_PEND);
}
@Override
public boolean execute(@NotNull Editor editor, @NotNull DataContext context, @NotNull Command cmd) {
final Argument argument = cmd.getArgument();
@ -102,7 +102,8 @@ public class FilterMotionAction extends VimCommandAction {
count = 1;
}
Command command = new Command(count, new EmptyAction(), Command.Type.UNDEFINED, EnumSet.noneOf(CommandFlags.class));
Command command =
new Command(count, new EmptyAction(), Command.Type.UNDEFINED, EnumSet.noneOf(CommandFlags.class));
VimPlugin.getProcess().startFilterCommand(editor, context, command);
return true;
@ -111,28 +112,28 @@ public class FilterMotionAction extends VimCommandAction {
}
private static class EmptyAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return Collections.emptySet();
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return Collections.emptySet();
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_SELF_SYNCHRONIZED;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new VimActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return Collections.emptySet();
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return Collections.emptySet();
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_SELF_SYNCHRONIZED;
}
@Override
public boolean execute(@NotNull Editor editor, @NotNull DataContext context, @NotNull Command cmd) {
return false;

52
src/com/maddyhome/idea/vim/action/change/change/FilterVisualLinesAction.java
View File

@ -43,6 +43,32 @@ final public class FilterVisualLinesAction extends VimCommandAction {
@Override
final protected VimActionHandler makeActionHandler() {
return new VimActionHandler.SingleExecution() {
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("!");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MOT_LINEWISE);
}
@Override
public boolean execute(@NotNull Editor editor, @NotNull DataContext context, @NotNull Command cmd) {
VimPlugin.getProcess().startFilterCommand(editor, context, cmd);
@ -51,30 +77,4 @@ final public class FilterVisualLinesAction extends VimCommandAction {
}
};
}
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("!");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MOT_LINEWISE);
}
}

60
src/com/maddyhome/idea/vim/action/change/change/ReformatCodeVisualAction.java
View File

@ -46,41 +46,41 @@ final public class ReformatCodeVisualAction extends VimCommandAction {
@Override
final protected VimActionHandler makeActionHandler() {
return new VisualOperatorActionHandler.ForEachCaret() {
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("gq");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MOT_LINEWISE, CommandFlags.FLAG_EXIT_VISUAL);
}
@Override
public boolean executeAction(@NotNull Editor editor,
@NotNull Caret caret,
@NotNull DataContext context,
@NotNull Command cmd,
@NotNull VimSelection range) {
@NotNull Caret caret,
@NotNull DataContext context,
@NotNull Command cmd,
@NotNull VimSelection range) {
VimPlugin.getChange().reformatCode(editor, range);
return true;
}
};
}
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("gq");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MOT_LINEWISE, CommandFlags.FLAG_EXIT_VISUAL);
}
}

36
src/com/maddyhome/idea/vim/action/change/change/number/ChangeNumberDecAction.java
View File

@ -37,28 +37,28 @@ import java.util.Set;
public class ChangeNumberDecAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-X>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.ForEachCaret() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-X>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull Caret caret,

36
src/com/maddyhome/idea/vim/action/change/change/number/ChangeNumberIncAction.java
View File

@ -37,28 +37,28 @@ import java.util.Set;
public class ChangeNumberIncAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-A>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.ForEachCaret() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-A>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull Caret caret,

60
src/com/maddyhome/idea/vim/action/change/change/number/ChangeVisualNumberAvalancheDecAction.java
View File

@ -43,41 +43,41 @@ final public class ChangeVisualNumberAvalancheDecAction extends VimCommandAction
@Override
final protected VimActionHandler makeActionHandler() {
return new VisualOperatorActionHandler.ForEachCaret() {
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("g<C-X>");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_EXIT_VISUAL);
}
@Override
public boolean executeAction(@NotNull Editor editor,
@NotNull Caret caret,
@NotNull DataContext context,
@NotNull Command cmd,
@NotNull VimSelection range) {
@NotNull Caret caret,
@NotNull DataContext context,
@NotNull Command cmd,
@NotNull VimSelection range) {
return VimPlugin.getChange()
.changeNumberVisualMode(editor, caret, range.toVimTextRange(false), -cmd.getCount(), true);
}
};
}
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("g<C-X>");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_EXIT_VISUAL);
}
}

60
src/com/maddyhome/idea/vim/action/change/change/number/ChangeVisualNumberAvalancheIncAction.java
View File

@ -43,41 +43,41 @@ final public class ChangeVisualNumberAvalancheIncAction extends VimCommandAction
@Override
final protected VimActionHandler makeActionHandler() {
return new VisualOperatorActionHandler.ForEachCaret() {
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("g<C-A>");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_EXIT_VISUAL);
}
@Override
public boolean executeAction(@NotNull Editor editor,
@NotNull Caret caret,
@NotNull DataContext context,
@NotNull Command cmd,
@NotNull VimSelection range) {
@NotNull Caret caret,
@NotNull DataContext context,
@NotNull Command cmd,
@NotNull VimSelection range) {
return VimPlugin.getChange()
.changeNumberVisualMode(editor, caret, range.toVimTextRange(false), cmd.getCount(), true);
}
};
}
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("g<C-A>");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_EXIT_VISUAL);
}
}

60
src/com/maddyhome/idea/vim/action/change/change/number/ChangeVisualNumberDecAction.java
View File

@ -43,41 +43,41 @@ final public class ChangeVisualNumberDecAction extends VimCommandAction {
@Override
final protected VimActionHandler makeActionHandler() {
return new VisualOperatorActionHandler.ForEachCaret() {
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-X>");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_EXIT_VISUAL);
}
@Override
public boolean executeAction(@NotNull Editor editor,
@NotNull Caret caret,
@NotNull DataContext context,
@NotNull Command cmd,
@NotNull VimSelection range) {
@NotNull Caret caret,
@NotNull DataContext context,
@NotNull Command cmd,
@NotNull VimSelection range) {
return VimPlugin.getChange()
.changeNumberVisualMode(editor, caret, range.toVimTextRange(false), -cmd.getCount(), false);
}
};
}
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-X>");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_EXIT_VISUAL);
}
}

60
src/com/maddyhome/idea/vim/action/change/change/number/ChangeVisualNumberIncAction.java
View File

@ -43,41 +43,41 @@ final public class ChangeVisualNumberIncAction extends VimCommandAction {
@Override
final protected VimActionHandler makeActionHandler() {
return new VisualOperatorActionHandler.ForEachCaret() {
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-A>");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_EXIT_VISUAL);
}
@Override
public boolean executeAction(@NotNull Editor editor,
@NotNull Caret caret,
@NotNull DataContext context,
@NotNull Command cmd,
@NotNull VimSelection range) {
@NotNull Caret caret,
@NotNull DataContext context,
@NotNull Command cmd,
@NotNull VimSelection range) {
return VimPlugin.getChange()
.changeNumberVisualMode(editor, caret, range.toVimTextRange(false), cmd.getCount(), false);
}
};
}
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-A>");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_EXIT_VISUAL);
}
}

36
src/com/maddyhome/idea/vim/action/change/delete/DeleteCharacterAction.java
View File

@ -37,28 +37,28 @@ import java.util.Set;
public class DeleteCharacterAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<DEL>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.DELETE;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.ForEachCaret() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<DEL>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.DELETE;
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull Caret caret,

36
src/com/maddyhome/idea/vim/action/change/delete/DeleteCharacterLeftAction.java
View File

@ -37,28 +37,28 @@ import java.util.Set;
public class DeleteCharacterLeftAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("X");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.DELETE;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.ForEachCaret() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("X");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.DELETE;
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull Caret caret,

36
src/com/maddyhome/idea/vim/action/change/delete/DeleteCharacterRightAction.java
View File

@ -37,28 +37,28 @@ import java.util.Set;
public class DeleteCharacterRightAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("x");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.DELETE;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.ForEachCaret() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("x");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.DELETE;
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull Caret caret,

36
src/com/maddyhome/idea/vim/action/change/delete/DeleteEndOfLineAction.java
View File

@ -37,28 +37,28 @@ import java.util.Set;
public class DeleteEndOfLineAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("D");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.DELETE;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.ForEachCaret() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("D");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.DELETE;
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull Caret caret,

36
src/com/maddyhome/idea/vim/action/change/delete/DeleteJoinLinesAction.java
View File

@ -38,28 +38,28 @@ import java.util.Set;
public class DeleteJoinLinesAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("gJ");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.DELETE;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("gJ");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.DELETE;
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull DataContext context,

36
src/com/maddyhome/idea/vim/action/change/delete/DeleteJoinLinesSpacesAction.java
View File

@ -38,28 +38,28 @@ import java.util.Set;
public class DeleteJoinLinesSpacesAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("J");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.DELETE;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("J");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.DELETE;
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull DataContext context,

53
src/com/maddyhome/idea/vim/action/change/delete/DeleteJoinVisualLinesAction.java
View File

@ -49,6 +49,33 @@ final public class DeleteJoinVisualLinesAction extends VimCommandAction {
@Override
final protected VimActionHandler makeActionHandler() {
return new VisualOperatorActionHandler.SingleExecution() {
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("gJ");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.DELETE;
}
@Contract(pure = true)
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_EXIT_VISUAL);
}
@Override
public boolean executeForAllCarets(@NotNull Editor editor,
@NotNull DataContext context,
@ -76,30 +103,4 @@ final public class DeleteJoinVisualLinesAction extends VimCommandAction {
};
}
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("gJ");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.DELETE;
}
@Contract(pure = true)
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_EXIT_VISUAL);
}
}

50
src/com/maddyhome/idea/vim/action/change/delete/DeleteJoinVisualLinesSpacesAction.java
View File

@ -49,6 +49,31 @@ final public class DeleteJoinVisualLinesSpacesAction extends VimCommandAction {
@Override
final protected VimActionHandler makeActionHandler() {
return new VisualOperatorActionHandler.SingleExecution() {
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("J");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.DELETE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_EXIT_VISUAL);
}
@Override
public boolean executeForAllCarets(@NotNull Editor editor,
@ -77,29 +102,4 @@ final public class DeleteJoinVisualLinesSpacesAction extends VimCommandAction {
};
}
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("J");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.DELETE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_EXIT_VISUAL);
}
}

48
src/com/maddyhome/idea/vim/action/change/delete/DeleteLineAction.java
View File

@ -43,34 +43,34 @@ public class DeleteLineAction extends VimCommandAction {
super();
}
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("dd");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.DELETE;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_ALLOW_MID_COUNT);
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.ForEachCaret() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("dd");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.DELETE;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_ALLOW_MID_COUNT);
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull Caret caret,

60
src/com/maddyhome/idea/vim/action/change/delete/DeleteMotionAction.java
View File

@ -39,40 +39,40 @@ import java.util.Set;
public class DeleteMotionAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("d");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.DELETE;
}
@NotNull
@Override
public Argument.Type getArgumentType() {
return Argument.Type.MOTION;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_OP_PEND);
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.ForEachCaret() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("d");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.DELETE;
}
@NotNull
@Override
public Argument.Type getArgumentType() {
return Argument.Type.MOTION;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_OP_PEND);
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull Caret caret,

59
src/com/maddyhome/idea/vim/action/change/delete/DeleteVisualAction.java
View File

@ -47,41 +47,42 @@ final public class DeleteVisualAction extends VimCommandAction {
@Override
final protected VimActionHandler makeActionHandler() {
return new VisualOperatorActionHandler.ForEachCaret() {
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("d", "x", "<Del>");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.DELETE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_EXIT_VISUAL);
}
@Override
public boolean executeAction(@NotNull Editor editor,
@NotNull Caret caret,
@NotNull DataContext context,
@NotNull Command cmd,
@NotNull VimSelection range) {
@NotNull Caret caret,
@NotNull DataContext context,
@NotNull Command cmd,
@NotNull VimSelection range) {
SelectionType selectionType = range.getType();
return VimPlugin.getChange().deleteRange(editor, caret, range.toVimTextRange(false), selectionType, false);
}
};
}
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("d", "x", "<Del>");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.DELETE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_EXIT_VISUAL);
}
}

71
src/com/maddyhome/idea/vim/action/change/delete/DeleteVisualLinesAction.java
View File

@ -46,50 +46,53 @@ final public class DeleteVisualLinesAction extends VimCommandAction {
@Override
final protected VimActionHandler makeActionHandler() {
return new VisualOperatorActionHandler.ForEachCaret() {
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("X");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.DELETE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MOT_LINEWISE, CommandFlags.FLAG_EXIT_VISUAL);
}
@Override
public boolean executeAction(@NotNull Editor editor,
@NotNull Caret caret,
@NotNull DataContext context,
@NotNull Command cmd,
@NotNull VimSelection range) {
@NotNull Caret caret,
@NotNull DataContext context,
@NotNull Command cmd,
@NotNull VimSelection range) {
final CommandState.SubMode mode = CommandState.getInstance(editor).getSubMode();
final TextRange textRange = range.toVimTextRange(false);
if (mode == CommandState.SubMode.VISUAL_BLOCK) {
return VimPlugin.getChange()
.deleteRange(editor, editor.getCaretModel().getPrimaryCaret(), textRange,
SelectionType.fromSubMode(mode), false);
} else {
final TextRange lineRange = new TextRange(EditorHelper.getLineStartForOffset(editor, textRange.getStartOffset()),
EditorHelper.getLineEndForOffset(editor, textRange.getEndOffset()) + 1);
.deleteRange(editor, editor.getCaretModel().getPrimaryCaret(), textRange, SelectionType.fromSubMode(mode),
false);
}
else {
final TextRange lineRange =
new TextRange(EditorHelper.getLineStartForOffset(editor, textRange.getStartOffset()),
EditorHelper.getLineEndForOffset(editor, textRange.getEndOffset()) + 1);
return VimPlugin.getChange().deleteRange(editor, caret, lineRange, SelectionType.LINE_WISE, false);
}
}
};
}
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("X");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.DELETE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MOT_LINEWISE, CommandFlags.FLAG_EXIT_VISUAL);
}
}

64
src/com/maddyhome/idea/vim/action/change/delete/DeleteVisualLinesEndAction.java
View File

@ -49,12 +49,38 @@ final public class DeleteVisualLinesEndAction extends VimCommandAction {
@Override
final protected VimActionHandler makeActionHandler() {
return new VisualOperatorActionHandler.ForEachCaret() {
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("D");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.DELETE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MOT_LINEWISE, CommandFlags.FLAG_EXIT_VISUAL);
}
@Override
public boolean executeAction(@NotNull Editor editor,
@NotNull Caret caret,
@NotNull DataContext context,
@NotNull Command cmd,
@NotNull VimSelection range) {
@NotNull Caret caret,
@NotNull DataContext context,
@NotNull Command cmd,
@NotNull VimSelection range) {
TextRange vimTextRange = range.toVimTextRange(true);
if (range.getType() == SelectionType.BLOCK_WISE) {
final int[] starts = vimTextRange.getStartOffsets();
@ -69,37 +95,13 @@ final public class DeleteVisualLinesEndAction extends VimCommandAction {
.deleteRange(editor, editor.getCaretModel().getPrimaryCaret(), blockRange, SelectionType.BLOCK_WISE, false);
}
else {
final TextRange lineRange = new TextRange(EditorHelper.getLineStartForOffset(editor, vimTextRange.getStartOffset()),
EditorHelper.getLineEndForOffset(editor, vimTextRange.getEndOffset()) + 1);
final TextRange lineRange =
new TextRange(EditorHelper.getLineStartForOffset(editor, vimTextRange.getStartOffset()),
EditorHelper.getLineEndForOffset(editor, vimTextRange.getEndOffset()) + 1);
return VimPlugin.getChange().deleteRange(editor, caret, lineRange, SelectionType.LINE_WISE, false);
}
}
};
}
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("D");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.DELETE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MOT_LINEWISE, CommandFlags.FLAG_EXIT_VISUAL);
}
}

48
src/com/maddyhome/idea/vim/action/change/insert/InsertAfterCursorAction.java
View File

@ -38,34 +38,34 @@ import java.util.Set;
public class InsertAfterCursorAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("a");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MULTIKEY_UNDO);
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("a");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MULTIKEY_UNDO);
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull DataContext context,

48
src/com/maddyhome/idea/vim/action/change/insert/InsertAfterLineEndAction.java
View File

@ -38,34 +38,34 @@ import java.util.Set;
public class InsertAfterLineEndAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("A");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MULTIKEY_UNDO);
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("A");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MULTIKEY_UNDO);
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull DataContext context,

48
src/com/maddyhome/idea/vim/action/change/insert/InsertAtPreviousInsertAction.java
View File

@ -38,34 +38,34 @@ import java.util.Set;
public class InsertAtPreviousInsertAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("gi");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MULTIKEY_UNDO);
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("gi");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MULTIKEY_UNDO);
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull DataContext context,

50
src/com/maddyhome/idea/vim/action/change/insert/InsertBeforeCursorAction.java
View File

@ -43,6 +43,31 @@ final public class InsertBeforeCursorAction extends VimCommandAction {
@Override
final protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.SingleExecution() {
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("i", "<Insert>");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MULTIKEY_UNDO);
}
@Override
final public boolean execute(@NotNull Editor editor, @NotNull DataContext context, int count, int rawCount,
@Nullable Argument argument) {
@ -52,29 +77,4 @@ final public class InsertBeforeCursorAction extends VimCommandAction {
};
}
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("i", "<Insert>");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MULTIKEY_UNDO);
}
}

48
src/com/maddyhome/idea/vim/action/change/insert/InsertBeforeFirstNonBlankAction.java
View File

@ -38,34 +38,34 @@ import java.util.Set;
public class InsertBeforeFirstNonBlankAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("I");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MULTIKEY_UNDO);
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("I");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MULTIKEY_UNDO);
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull DataContext context,

36
src/com/maddyhome/idea/vim/action/change/insert/InsertCharacterAboveCursorAction.java
View File

@ -37,28 +37,28 @@ import java.util.Set;
public class InsertCharacterAboveCursorAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.I;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-Y>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.ForEachCaret() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.I;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-Y>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull Caret caret,

36
src/com/maddyhome/idea/vim/action/change/insert/InsertCharacterBelowCursorAction.java
View File

@ -37,28 +37,28 @@ import java.util.Set;
public class InsertCharacterBelowCursorAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.I;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-E>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.ForEachCaret() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.I;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-E>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull Caret caret,

48
src/com/maddyhome/idea/vim/action/change/insert/InsertDeleteInsertedTextAction.java
View File

@ -39,34 +39,34 @@ import java.util.Set;
public class InsertDeleteInsertedTextAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.I;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-U>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_CLEAR_STROKES);
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.ForEachCaret() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.I;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-U>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_CLEAR_STROKES);
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull Caret caret,

48
src/com/maddyhome/idea/vim/action/change/insert/InsertDeletePreviousWordAction.java
View File

@ -39,34 +39,34 @@ import java.util.Set;
public class InsertDeletePreviousWordAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.I;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-W>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_CLEAR_STROKES);
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.ForEachCaret() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.I;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-W>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_CLEAR_STROKES);
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull Caret caret,

48
src/com/maddyhome/idea/vim/action/change/insert/InsertEnterAction.java
View File

@ -36,34 +36,34 @@ import java.util.Set;
public class InsertEnterAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.I;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-M>", "<CR>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_SAVE_STROKE);
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new VimActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.I;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-M>", "<CR>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_SAVE_STROKE);
}
@Override
public boolean execute(@NotNull Editor editor, @NotNull DataContext context, @NotNull Command cmd) {
VimPlugin.getChange().processEnter(HelperKt.getTopLevelEditor(editor), context);

40
src/com/maddyhome/idea/vim/action/change/insert/InsertExitModeAction.java
View File

@ -42,6 +42,26 @@ final public class InsertExitModeAction extends VimCommandAction {
@Override
final protected VimActionHandler makeActionHandler() {
return new VimActionHandler.SingleExecution() {
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.I;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-[>", "<C-C>", "<Esc>", "<C-\\><C-N>");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.INSERT;
}
@Override
public boolean execute(@NotNull Editor editor, @NotNull DataContext context, @NotNull Command cmd) {
VimPlugin.getChange().processEscape(editor, context);
@ -50,26 +70,6 @@ final public class InsertExitModeAction extends VimCommandAction {
};
}
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.I;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-[>", "<C-C>", "<Esc>", "<C-\\><C-N>");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
public static VimCommandActionBase getInstance() {
return RegisterActions.findActionOrDie(ACTION_ID);

48
src/com/maddyhome/idea/vim/action/change/insert/InsertInsertAction.java
View File

@ -35,34 +35,34 @@ import java.util.Set;
public class InsertInsertAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.I;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<Ins>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_SAVE_STROKE);
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new VimActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.I;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<Ins>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_SAVE_STROKE);
}
@Override
public boolean execute(@NotNull Editor editor, @NotNull DataContext context, @NotNull Command cmd) {
VimPlugin.getChange().processInsert(editor);

48
src/com/maddyhome/idea/vim/action/change/insert/InsertLineStartAction.java
View File

@ -38,34 +38,34 @@ import java.util.Set;
public class InsertLineStartAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("gI");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MULTIKEY_UNDO);
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("gI");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MULTIKEY_UNDO);
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull DataContext context,

48
src/com/maddyhome/idea/vim/action/change/insert/InsertNewLineAboveAction.java
View File

@ -38,34 +38,34 @@ import java.util.Set;
public class InsertNewLineAboveAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("O");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MULTIKEY_UNDO);
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("O");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MULTIKEY_UNDO);
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull DataContext context,

48
src/com/maddyhome/idea/vim/action/change/insert/InsertNewLineBelowAction.java
View File

@ -38,34 +38,34 @@ import java.util.Set;
public class InsertNewLineBelowAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("o");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MULTIKEY_UNDO);
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("o");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MULTIKEY_UNDO);
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull DataContext context,

36
src/com/maddyhome/idea/vim/action/change/insert/InsertPreviousInsertAction.java
View File

@ -36,28 +36,28 @@ import java.util.Set;
public class InsertPreviousInsertAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.I;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-A>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.I;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-A>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull DataContext context,

44
src/com/maddyhome/idea/vim/action/change/insert/InsertPreviousInsertExitAction.java
View File

@ -39,32 +39,32 @@ import java.util.Set;
public class InsertPreviousInsertExitAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.I;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
Set<List<KeyStroke>> keys = new HashSet<>();
keys.add(Collections.singletonList(KeyStroke.getKeyStroke(KeyEvent.VK_2, KeyEvent.CTRL_MASK | KeyEvent.SHIFT_MASK)));
keys.add(Collections.singletonList(KeyStroke.getKeyStroke(KeyEvent.VK_2, KeyEvent.CTRL_MASK)));
keys.add(Collections.singletonList(KeyStroke.getKeyStroke(KeyEvent.VK_AT, KeyEvent.CTRL_MASK)));
return keys;
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.I;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
Set<List<KeyStroke>> keys = new HashSet<>();
keys.add(Collections.singletonList(KeyStroke.getKeyStroke(KeyEvent.VK_2, KeyEvent.CTRL_MASK | KeyEvent.SHIFT_MASK)));
keys.add(Collections.singletonList(KeyStroke.getKeyStroke(KeyEvent.VK_2, KeyEvent.CTRL_MASK)));
keys.add(Collections.singletonList(KeyStroke.getKeyStroke(KeyEvent.VK_AT, KeyEvent.CTRL_MASK)));
return keys;
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull DataContext context,

48
src/com/maddyhome/idea/vim/action/change/insert/InsertRegisterAction.java
View File

@ -34,34 +34,34 @@ import java.util.Set;
public class InsertRegisterAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.I;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-R>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
public Argument.Type getArgumentType() {
return Argument.Type.CHARACTER;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new VimActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.I;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-R>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
public Argument.Type getArgumentType() {
return Argument.Type.CHARACTER;
}
@Override
public boolean execute(@NotNull Editor editor, @NotNull DataContext context, @NotNull Command cmd) {
final Argument argument = cmd.getArgument();

48
src/com/maddyhome/idea/vim/action/change/insert/InsertSingleCommandAction.java
View File

@ -35,34 +35,34 @@ import java.util.Set;
public class InsertSingleCommandAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.I;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-O>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_CLEAR_STROKES, CommandFlags.FLAG_EXPECT_MORE);
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new VimActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.I;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-O>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_CLEAR_STROKES, CommandFlags.FLAG_EXPECT_MORE);
}
@Override
public boolean execute(@NotNull Editor editor, @NotNull DataContext context, @NotNull Command cmd) {
VimPlugin.getChange().processSingleCommand(editor);

52
src/com/maddyhome/idea/vim/action/change/insert/VisualBlockAppendAction.java
View File

@ -48,6 +48,32 @@ final public class VisualBlockAppendAction extends VimCommandAction {
@Override
final protected VimActionHandler makeActionHandler() {
return new VisualOperatorActionHandler.SingleExecution() {
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@Contract(pure = true)
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("A");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MULTIKEY_UNDO, CommandFlags.FLAG_EXIT_VISUAL);
}
@Override
final public boolean executeForAllCarets(@NotNull Editor editor,
@NotNull DataContext context,
@ -67,30 +93,4 @@ final public class VisualBlockAppendAction extends VimCommandAction {
};
}
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@Contract(pure = true)
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("A");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MULTIKEY_UNDO, CommandFlags.FLAG_EXIT_VISUAL);
}
}

50
src/com/maddyhome/idea/vim/action/change/insert/VisualBlockInsertAction.java
View File

@ -48,6 +48,31 @@ final public class VisualBlockInsertAction extends VimCommandAction {
@Override
final protected VimActionHandler makeActionHandler() {
return new VisualOperatorActionHandler.SingleExecution() {
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("I");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MULTIKEY_UNDO, CommandFlags.FLAG_EXIT_VISUAL);
}
@Override
final public boolean executeForAllCarets(@NotNull Editor editor,
@NotNull DataContext context,
@ -67,29 +92,4 @@ final public class VisualBlockInsertAction extends VimCommandAction {
};
}
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("I");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.INSERT;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MULTIKEY_UNDO, CommandFlags.FLAG_EXIT_VISUAL);
}
}

36
src/com/maddyhome/idea/vim/action/change/shift/AutoIndentLinesAction.java
View File

@ -37,28 +37,28 @@ import java.util.Set;
public class AutoIndentLinesAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("==");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.ForEachCaret() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("==");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull Caret caret,

60
src/com/maddyhome/idea/vim/action/change/shift/AutoIndentMotionAction.java
View File

@ -41,40 +41,40 @@ import java.util.Set;
* @author Aleksey Lagoshin
*/
public class AutoIndentMotionAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("=");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_OP_PEND);
}
@NotNull
@Override
public Argument.Type getArgumentType() {
return Argument.Type.MOTION;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.ForEachCaret() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("=");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_OP_PEND);
}
@NotNull
@Override
public Argument.Type getArgumentType() {
return Argument.Type.MOTION;
}
@Override
public boolean execute(@NotNull Editor editor, @NotNull Caret caret, @NotNull DataContext context, int count,
int rawCount, @Nullable Argument argument) {

50
src/com/maddyhome/idea/vim/action/change/shift/ShiftLeftLinesAction.kt
View File

@ -23,6 +23,7 @@ import com.intellij.openapi.editor.Caret
import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.action.VimCommandAction
import com.maddyhome.idea.vim.action.VimCommandActionBase
import com.maddyhome.idea.vim.command.Argument
import com.maddyhome.idea.vim.command.Command
import com.maddyhome.idea.vim.command.CommandFlags
@ -34,36 +35,45 @@ import javax.swing.KeyStroke
class ShiftLeftLinesAction : VimCommandAction() {
override val mappingModes: Set<MappingMode> = MappingMode.I
override fun makeActionHandler(): VimActionHandler = object : ChangeEditorActionHandler.ForEachCaret() {
override val mappingModes: Set<MappingMode> = MappingMode.I
override val keyStrokesSet: Set<List<KeyStroke>> = parseKeysSet("<C-D>")
override val keyStrokesSet: Set<List<KeyStroke>> = VimCommandActionBase.parseKeysSet("<C-D>")
override val type: Command.Type = Command.Type.INSERT
override val type: Command.Type = Command.Type.INSERT
override val flags: EnumSet<CommandFlags> = EnumSet.of(CommandFlags.FLAG_SAVE_STROKE)
override val flags: EnumSet<CommandFlags> = EnumSet.of(CommandFlags.FLAG_SAVE_STROKE)
override fun makeActionHandler(): VimActionHandler = ShiftLeftLinesActionHandler
override fun execute(editor: Editor,
caret: Caret,
context: DataContext,
count: Int,
rawCount: Int,
argument: Argument?): Boolean {
VimPlugin.getChange().indentLines(editor, caret, context, count, -1)
return true
}
}
}
class ShiftLeftLinesNormalModeAction : VimCommandAction() {
override val mappingModes: Set<MappingMode> = MappingMode.N
override fun makeActionHandler(): VimActionHandler = object : ChangeEditorActionHandler.ForEachCaret() {
override val mappingModes: Set<MappingMode> = MappingMode.N
override val keyStrokesSet: Set<List<KeyStroke>> = parseKeysSet("<<")
override val keyStrokesSet: Set<List<KeyStroke>> = VimCommandActionBase.parseKeysSet("<<")
override val type: Command.Type = Command.Type.CHANGE
override val type: Command.Type = Command.Type.CHANGE
override fun makeActionHandler(): VimActionHandler = ShiftLeftLinesActionHandler
}
override fun execute(editor: Editor,
caret: Caret,
context: DataContext,
count: Int,
rawCount: Int,
argument: Argument?): Boolean {
VimPlugin.getChange().indentLines(editor, caret, context, count, -1)
private object ShiftLeftLinesActionHandler : ChangeEditorActionHandler.ForEachCaret() {
override fun execute(editor: Editor,
caret: Caret,
context: DataContext,
count: Int,
rawCount: Int,
argument: Argument?): Boolean {
VimPlugin.getChange().indentLines(editor, caret, context, count, -1)
return true
return true
}
}
}

60
src/com/maddyhome/idea/vim/action/change/shift/ShiftLeftMotionAction.java
View File

@ -39,40 +39,40 @@ import java.util.Set;
public class ShiftLeftMotionAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
public Argument.Type getArgumentType() {
return Argument.Type.MOTION;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_OP_PEND);
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.ForEachCaret() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
public Argument.Type getArgumentType() {
return Argument.Type.MOTION;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_OP_PEND);
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull Caret caret,

50
src/com/maddyhome/idea/vim/action/change/shift/ShiftLeftVisualAction.java
View File

@ -46,6 +46,31 @@ final public class ShiftLeftVisualAction extends VimCommandAction {
@Override
final protected VimActionHandler makeActionHandler() {
return new VisualOperatorActionHandler.ForEachCaret() {
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_EXIT_VISUAL);
}
@Override
public boolean executeAction(@NotNull Editor editor,
@NotNull Caret caret,
@ -58,29 +83,4 @@ final public class ShiftLeftVisualAction extends VimCommandAction {
};
}
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_EXIT_VISUAL);
}
}

42
src/com/maddyhome/idea/vim/action/change/shift/ShiftRightLinesAction.kt
View File

@ -23,6 +23,7 @@ import com.intellij.openapi.editor.Caret
import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.action.VimCommandAction
import com.maddyhome.idea.vim.action.VimCommandActionBase
import com.maddyhome.idea.vim.command.Argument
import com.maddyhome.idea.vim.command.Command
import com.maddyhome.idea.vim.command.CommandFlags
@ -34,31 +35,40 @@ import javax.swing.KeyStroke
class ShiftRightLinesAction : VimCommandAction() {
override val mappingModes: Set<MappingMode> = MappingMode.I
override fun makeActionHandler(): VimActionHandler = object : ChangeEditorActionHandler.ForEachCaret() {
override val mappingModes: Set<MappingMode> = MappingMode.I
override val keyStrokesSet: Set<List<KeyStroke>> = parseKeysSet("<C-T>")
override val keyStrokesSet: Set<List<KeyStroke>> = VimCommandActionBase.parseKeysSet("<C-T>")
override val type: Command.Type = Command.Type.INSERT
override val type: Command.Type = Command.Type.INSERT
override val flags: EnumSet<CommandFlags> = EnumSet.of(CommandFlags.FLAG_SAVE_STROKE)
override val flags: EnumSet<CommandFlags> = EnumSet.of(CommandFlags.FLAG_SAVE_STROKE)
override fun makeActionHandler(): VimActionHandler = ShiftRightLinesActionHandler
override fun execute(editor: Editor,
caret: Caret,
context: DataContext,
count: Int,
rawCount: Int,
argument: Argument?): Boolean {
VimPlugin.getChange().indentLines(editor, caret, context, count, -1)
return true
}
}
}
class ShiftRightLinesNormalModeAction : VimCommandAction() {
override val mappingModes: Set<MappingMode> = MappingMode.N
override fun makeActionHandler(): VimActionHandler = object : ChangeEditorActionHandler.ForEachCaret() {
override val mappingModes: Set<MappingMode> = MappingMode.N
override val keyStrokesSet: Set<List<KeyStroke>> = parseKeysSet(">>")
override val keyStrokesSet: Set<List<KeyStroke>> = VimCommandActionBase.parseKeysSet(">>")
override val type: Command.Type = Command.Type.CHANGE
override val type: Command.Type = Command.Type.CHANGE
override fun makeActionHandler(): VimActionHandler = ShiftRightLinesActionHandler
}
private object ShiftRightLinesActionHandler : ChangeEditorActionHandler.ForEachCaret() {
override fun execute(editor: Editor, caret: Caret, context: DataContext, count: Int,
rawCount: Int, argument: Argument?): Boolean {
VimPlugin.getChange().indentLines(editor, caret, context, count, 1)
return true
override fun execute(editor: Editor, caret: Caret, context: DataContext, count: Int,
rawCount: Int, argument: Argument?): Boolean {
VimPlugin.getChange().indentLines(editor, caret, context, count, 1)
return true
}
}
}

60
src/com/maddyhome/idea/vim/action/change/shift/ShiftRightMotionAction.java
View File

@ -39,40 +39,40 @@ import java.util.Set;
public class ShiftRightMotionAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet(">");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
public Argument.Type getArgumentType() {
return Argument.Type.MOTION;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_OP_PEND);
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.ForEachCaret() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet(">");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
public Argument.Type getArgumentType() {
return Argument.Type.MOTION;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_OP_PEND);
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull Caret caret,

59
src/com/maddyhome/idea/vim/action/change/shift/ShiftRightVisualAction.java
View File

@ -46,41 +46,42 @@ final public class ShiftRightVisualAction extends VimCommandAction {
@Override
final protected VimActionHandler makeActionHandler() {
return new VisualOperatorActionHandler.ForEachCaret() {
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet(">");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_EXIT_VISUAL);
}
@Override
public boolean executeAction(@NotNull Editor editor,
@NotNull Caret caret,
@NotNull DataContext context,
@NotNull Command cmd,
@NotNull VimSelection range) {
@NotNull Caret caret,
@NotNull DataContext context,
@NotNull Command cmd,
@NotNull VimSelection range) {
VimPlugin.getChange().indentRange(editor, caret, context, range.toVimTextRange(false), cmd.getCount(), 1);
return true;
}
};
}
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet(">");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.CHANGE;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_EXIT_VISUAL);
}
}

36
src/com/maddyhome/idea/vim/action/copy/PutTextAfterCursorAction.java
View File

@ -37,28 +37,28 @@ import java.util.List;
import java.util.Set;
public class PutTextAfterCursorAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("p");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_SELF_SYNCHRONIZED;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("p");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_SELF_SYNCHRONIZED;
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull DataContext context,

36
src/com/maddyhome/idea/vim/action/copy/PutTextAfterCursorActionMoveCursor.java
View File

@ -38,28 +38,28 @@ import java.util.Set;
public class PutTextAfterCursorActionMoveCursor extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("gp");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_SELF_SYNCHRONIZED;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("gp");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_SELF_SYNCHRONIZED;
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull DataContext context,

36
src/com/maddyhome/idea/vim/action/copy/PutTextAfterCursorNoIndentAction.java
View File

@ -38,28 +38,28 @@ import java.util.Set;
public class PutTextAfterCursorNoIndentAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("]p");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_SELF_SYNCHRONIZED;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("]p");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_SELF_SYNCHRONIZED;
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull DataContext context,

36
src/com/maddyhome/idea/vim/action/copy/PutTextBeforeCursorAction.java
View File

@ -37,28 +37,28 @@ import java.util.List;
import java.util.Set;
public class PutTextBeforeCursorAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("P");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_SELF_SYNCHRONIZED;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("P");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_SELF_SYNCHRONIZED;
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull DataContext context,

36
src/com/maddyhome/idea/vim/action/copy/PutTextBeforeCursorActionMoveCursor.java
View File

@ -38,28 +38,28 @@ import java.util.Set;
public class PutTextBeforeCursorActionMoveCursor extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("gP");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_SELF_SYNCHRONIZED;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("gP");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_SELF_SYNCHRONIZED;
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull DataContext context,

36
src/com/maddyhome/idea/vim/action/copy/PutTextBeforeCursorNoIndentAction.java
View File

@ -38,28 +38,28 @@ import java.util.Set;
public class PutTextBeforeCursorNoIndentAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("[P", "]P", "[p");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_SELF_SYNCHRONIZED;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new ChangeEditorActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("[P", "]P", "[p");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_SELF_SYNCHRONIZED;
}
@Override
public boolean execute(@NotNull Editor editor,
@NotNull DataContext context,

16
src/com/maddyhome/idea/vim/action/copy/PutVisualTextAction.kt
View File

@ -23,6 +23,7 @@ import com.intellij.openapi.editor.Caret
import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.action.VimCommandAction
import com.maddyhome.idea.vim.action.VimCommandActionBase
import com.maddyhome.idea.vim.command.Command
import com.maddyhome.idea.vim.command.CommandFlags
import com.maddyhome.idea.vim.command.MappingMode
@ -39,6 +40,13 @@ import javax.swing.KeyStroke
*/
class PutVisualTextAction : VimCommandAction() {
override fun makeActionHandler(): VimActionHandler = object : VisualOperatorActionHandler.SingleExecution() {
override val mappingModes: Set<MappingMode> = MappingMode.V
override val keyStrokesSet: Set<List<KeyStroke>> = VimCommandActionBase.parseKeysSet("p", "P")
override val type: Command.Type = Command.Type.OTHER_SELF_SYNCHRONIZED
override val flags: EnumSet<CommandFlags> = enumSetOf(CommandFlags.FLAG_EXIT_VISUAL)
override fun executeForAllCarets(editor: Editor,
context: DataContext,
cmd: Command,
@ -54,12 +62,4 @@ class PutVisualTextAction : VimCommandAction() {
return VimPlugin.getPut().putText(editor, context, putData)
}
}
override val mappingModes: Set<MappingMode> = MappingMode.V
override val keyStrokesSet: Set<List<KeyStroke>> = parseKeysSet("p", "P")
override val type: Command.Type = Command.Type.OTHER_SELF_SYNCHRONIZED
override val flags: EnumSet<CommandFlags> = enumSetOf(CommandFlags.FLAG_EXIT_VISUAL)
}

18
src/com/maddyhome/idea/vim/action/copy/PutVisualTextMoveCursorAction.kt
View File

@ -23,6 +23,7 @@ import com.intellij.openapi.editor.Caret
import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.action.VimCommandAction
import com.maddyhome.idea.vim.action.VimCommandActionBase
import com.maddyhome.idea.vim.command.Command
import com.maddyhome.idea.vim.command.CommandFlags
import com.maddyhome.idea.vim.command.MappingMode
@ -39,6 +40,15 @@ import javax.swing.KeyStroke
*/
class PutVisualTextMoveCursorAction : VimCommandAction() {
override fun makeActionHandler(): VimActionHandler = object : VisualOperatorActionHandler.SingleExecution() {
override val mappingModes: Set<MappingMode> = MappingMode.V
override val keyStrokesSet: Set<List<KeyStroke>> = VimCommandActionBase.parseKeysSet("gp", "gP")
override val type: Command.Type = Command.Type.OTHER_SELF_SYNCHRONIZED
override val flags: EnumSet<CommandFlags> = enumSetOf(CommandFlags.FLAG_EXIT_VISUAL)
override fun executeForAllCarets(editor: Editor, context: DataContext, cmd: Command, caretsAndSelections: Map<Caret, VimSelection>): Boolean {
if (caretsAndSelections.isEmpty()) return false
val textData = VimPlugin.getRegister().lastRegister?.let { PutData.TextData(it.text, it.type, it.transferableData) }
@ -51,12 +61,4 @@ class PutVisualTextMoveCursorAction : VimCommandAction() {
return VimPlugin.getPut().putText(editor, context, putData)
}
}
override val mappingModes: Set<MappingMode> = MappingMode.V
override val keyStrokesSet: Set<List<KeyStroke>> = parseKeysSet("gp", "gP")
override val type: Command.Type = Command.Type.OTHER_SELF_SYNCHRONIZED
override val flags: EnumSet<CommandFlags> = enumSetOf(CommandFlags.FLAG_EXIT_VISUAL)
}

18
src/com/maddyhome/idea/vim/action/copy/PutVisualTextNoIndentAction.kt
View File

@ -23,6 +23,7 @@ import com.intellij.openapi.editor.Caret
import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.action.VimCommandAction
import com.maddyhome.idea.vim.action.VimCommandActionBase
import com.maddyhome.idea.vim.command.Command
import com.maddyhome.idea.vim.command.CommandFlags
import com.maddyhome.idea.vim.command.MappingMode
@ -39,6 +40,15 @@ import javax.swing.KeyStroke
*/
class PutVisualTextNoIndentAction : VimCommandAction() {
override fun makeActionHandler(): VimActionHandler = object : VisualOperatorActionHandler.SingleExecution() {
override val mappingModes: Set<MappingMode> = MappingMode.V
override val keyStrokesSet: Set<List<KeyStroke>> = VimCommandActionBase.parseKeysSet("[p", "]p", "[P", "]P")
override val type: Command.Type = Command.Type.OTHER_SELF_SYNCHRONIZED
override val flags: EnumSet<CommandFlags> = enumSetOf(CommandFlags.FLAG_EXIT_VISUAL)
override fun executeForAllCarets(editor: Editor, context: DataContext, cmd: Command, caretsAndSelections: Map<Caret, VimSelection>): Boolean {
if (caretsAndSelections.isEmpty()) return false
val textData = VimPlugin.getRegister().lastRegister?.let { PutData.TextData(it.text, it.type, it.transferableData) }
@ -51,12 +61,4 @@ class PutVisualTextNoIndentAction : VimCommandAction() {
return VimPlugin.getPut().putText(editor, context, putData)
}
}
override val mappingModes: Set<MappingMode> = MappingMode.V
override val keyStrokesSet: Set<List<KeyStroke>> = parseKeysSet("[p", "]p", "[P", "]P")
override val type: Command.Type = Command.Type.OTHER_SELF_SYNCHRONIZED
override val flags: EnumSet<CommandFlags> = enumSetOf(CommandFlags.FLAG_EXIT_VISUAL)
}

60
src/com/maddyhome/idea/vim/action/copy/SelectRegisterAction.java
View File

@ -36,40 +36,40 @@ import java.util.Set;
public class SelectRegisterAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.NVO;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("\"");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.SELECT_REGISTER;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_EXPECT_MORE);
}
@NotNull
@Override
public Argument.Type getArgumentType() {
return Argument.Type.CHARACTER;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new VimActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.NVO;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("\"");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.SELECT_REGISTER;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_EXPECT_MORE);
}
@NotNull
@Override
public Argument.Type getArgumentType() {
return Argument.Type.CHARACTER;
}
@Override
public boolean execute(@NotNull Editor editor, @NotNull DataContext context, @NotNull Command cmd) {
final Argument argument = cmd.getArgument();

33
src/com/maddyhome/idea/vim/action/copy/YankLineAction.kt
View File

@ -22,6 +22,7 @@ import com.intellij.openapi.actionSystem.DataContext
import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.VimPlugin
import com.maddyhome.idea.vim.action.VimCommandAction
import com.maddyhome.idea.vim.action.VimCommandActionBase
import com.maddyhome.idea.vim.command.Command
import com.maddyhome.idea.vim.command.CommandFlags
import com.maddyhome.idea.vim.command.MappingMode
@ -32,29 +33,33 @@ import javax.swing.KeyStroke
class YankLineAction : VimCommandAction() {
override val mappingModes: Set<MappingMode> = MappingMode.N
override val keyStrokesSet: Set<List<KeyStroke>> = parseKeysSet("Y")
override fun makeActionHandler(): VimActionHandler = object : VimActionHandler.SingleExecution() {
override val mappingModes: Set<MappingMode> = MappingMode.N
override val type: Command.Type = Command.Type.COPY
override val keyStrokesSet: Set<List<KeyStroke>> = VimCommandActionBase.parseKeysSet("Y")
override fun makeActionHandler(): VimActionHandler = YankLineActionHandler
override val type: Command.Type = Command.Type.COPY
override fun execute(editor: Editor, context: DataContext, cmd: Command): Boolean {
return VimPlugin.getYank().yankLine(editor, cmd.count)
}
}
}
class YankLineMidCountAction : VimCommandAction() {
override val mappingModes: Set<MappingMode> = MappingMode.N
override fun makeActionHandler(): VimActionHandler = object : VimActionHandler.SingleExecution() {
override val mappingModes: Set<MappingMode> = MappingMode.N
override val keyStrokesSet: Set<List<KeyStroke>> = parseKeysSet("yy")
override val keyStrokesSet: Set<List<KeyStroke>> = VimCommandActionBase.parseKeysSet("yy")
override val type: Command.Type = Command.Type.COPY
override val type: Command.Type = Command.Type.COPY
override val flags: EnumSet<CommandFlags> = enumSetOf(CommandFlags.FLAG_ALLOW_MID_COUNT)
override val flags: EnumSet<CommandFlags> = enumSetOf(CommandFlags.FLAG_ALLOW_MID_COUNT)
override fun makeActionHandler(): VimActionHandler = YankLineActionHandler
}
private object YankLineActionHandler : VimActionHandler.SingleExecution() {
override fun execute(editor: Editor, context: DataContext, cmd: Command): Boolean {
return VimPlugin.getYank().yankLine(editor, cmd.count)
override fun execute(editor: Editor, context: DataContext, cmd: Command): Boolean {
return VimPlugin.getYank().yankLine(editor, cmd.count)
}
}
}

60
src/com/maddyhome/idea/vim/action/copy/YankMotionAction.java
View File

@ -36,40 +36,40 @@ import java.util.Set;
public class YankMotionAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("y");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.COPY;
}
@NotNull
@Override
public Argument.Type getArgumentType() {
return Argument.Type.MOTION;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_OP_PEND);
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new VimActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("y");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.COPY;
}
@NotNull
@Override
public Argument.Type getArgumentType() {
return Argument.Type.MOTION;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_OP_PEND);
}
@Override
public boolean execute(@NotNull Editor editor, @NotNull DataContext context, @NotNull Command cmd) {
final Argument argument = cmd.getArgument();

48
src/com/maddyhome/idea/vim/action/copy/YankVisualAction.java
View File

@ -45,6 +45,30 @@ final public class YankVisualAction extends VimCommandAction {
@Override
final protected VimActionHandler makeActionHandler() {
return new VisualOperatorActionHandler.SingleExecution() {
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("y");
}
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.COPY;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_EXIT_VISUAL);
}
@Override
final public boolean executeForAllCarets(@NotNull Editor editor,
@NotNull DataContext context,
@ -68,28 +92,4 @@ final public class YankVisualAction extends VimCommandAction {
};
}
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("y");
}
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.COPY;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_EXIT_VISUAL);
}
}

57
src/com/maddyhome/idea/vim/action/copy/YankVisualLinesAction.java
View File

@ -46,10 +46,37 @@ final public class YankVisualLinesAction extends VimCommandAction {
@Override
final protected VimActionHandler makeActionHandler() {
return new VisualOperatorActionHandler.SingleExecution() {
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("Y");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.COPY;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MOT_LINEWISE, CommandFlags.FLAG_EXIT_VISUAL);
}
@Override
final public boolean executeForAllCarets(@NotNull Editor editor,
@NotNull DataContext context,
@NotNull Command cmd, @NotNull Map<Caret, ? extends VimSelection> caretsAndSelections) {
@NotNull DataContext context,
@NotNull Command cmd,
@NotNull Map<Caret, ? extends VimSelection> caretsAndSelections) {
Collection<? extends VimSelection> selections = caretsAndSelections.values();
List<Integer> starts = new ArrayList<>();
List<Integer> ends = new ArrayList<>();
@ -73,30 +100,4 @@ final public class YankVisualLinesAction extends VimCommandAction {
}
};
}
@Contract(pure = true)
@NotNull
@Override
final public Set<MappingMode> getMappingModes() {
return MappingMode.V;
}
@NotNull
@Override
final public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("Y");
}
@Contract(pure = true)
@NotNull
@Override
final public Command.Type getType() {
return Command.Type.COPY;
}
@NotNull
@Override
final public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_MOT_LINEWISE, CommandFlags.FLAG_EXIT_VISUAL);
}
}

145
src/com/maddyhome/idea/vim/action/editor/VimEditorActions.kt
View File

@ -1,93 +1,138 @@
package com.maddyhome.idea.vim.action.editor
import com.maddyhome.idea.vim.action.NativeAction
import com.intellij.openapi.actionSystem.DataContext
import com.intellij.openapi.editor.Editor
import com.maddyhome.idea.vim.KeyHandler
import com.maddyhome.idea.vim.action.VimCommandAction
import com.maddyhome.idea.vim.command.Command
import com.maddyhome.idea.vim.command.CommandFlags
import com.maddyhome.idea.vim.command.MappingMode
import com.maddyhome.idea.vim.handler.VimActionHandler
import com.maddyhome.idea.vim.helper.enumSetOf
import com.maddyhome.idea.vim.key.Shortcut
import java.awt.event.KeyEvent
import java.util.*
import javax.swing.KeyStroke
class VimEditorBackSpace : NativeAction() {
override val actionName: String = "EditorBackSpace"
class VimEditorBackSpace : VimCommandAction() {
override fun makeActionHandler(): VimActionHandler = object : VimActionHandler.SingleExecution() {
val actionName: String = "EditorBackSpace"
override val mappingModes: Set<MappingMode> = MappingMode.I
override val mappingModes: Set<MappingMode> = MappingMode.I
override val keyStrokesSet: Set<List<KeyStroke>> = setOf(
listOf(KeyStroke.getKeyStroke(KeyEvent.VK_H, KeyEvent.CTRL_MASK)),
listOf(KeyStroke.getKeyStroke(KeyEvent.VK_BACK_SPACE, 0))
)
override val keyStrokesSet: Set<List<KeyStroke>> = setOf(
listOf(KeyStroke.getKeyStroke(KeyEvent.VK_H, KeyEvent.CTRL_MASK)),
listOf(KeyStroke.getKeyStroke(KeyEvent.VK_BACK_SPACE, 0))
)
override val type: Command.Type = Command.Type.INSERT
override val type: Command.Type = Command.Type.INSERT
override fun execute(editor: Editor, context: DataContext, cmd: Command): Boolean {
KeyHandler.executeAction(actionName, context)
return true
}
}
}
class VimEditorDelete : NativeAction() {
override val actionName: String = "EditorDelete"
class VimEditorDelete : VimCommandAction() {
override fun makeActionHandler(): VimActionHandler = object : VimActionHandler.SingleExecution() {
val actionName: String = "EditorDelete"
override val mappingModes: Set<MappingMode> = MappingMode.I
override val mappingModes: Set<MappingMode> = MappingMode.I
override val keyStrokesSet: Set<List<KeyStroke>> = setOf(
listOf(KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, 0))
)
override val keyStrokesSet: Set<List<KeyStroke>> = setOf(
listOf(KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, 0))
)
override val type: Command.Type = Command.Type.INSERT
override val type: Command.Type = Command.Type.INSERT
override val flags: EnumSet<CommandFlags> = enumSetOf(CommandFlags.FLAG_SAVE_STROKE)
override val flags: EnumSet<CommandFlags> = enumSetOf(CommandFlags.FLAG_SAVE_STROKE)
override fun execute(editor: Editor, context: DataContext, cmd: Command): Boolean {
KeyHandler.executeAction(actionName, context)
return true
}
}
}
class VimEditorDown : NativeAction() {
override val actionName: String = "EditorDown"
class VimEditorDown : VimCommandAction() {
override fun makeActionHandler(): VimActionHandler = object : VimActionHandler.SingleExecution() {
val actionName: String = "EditorDown"
override val mappingModes: Set<MappingMode> = MappingMode.I
override val mappingModes: Set<MappingMode> = MappingMode.I
override val keyStrokesSet: Set<List<KeyStroke>> = setOf(
listOf(KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, 0)),
listOf(KeyStroke.getKeyStroke(KeyEvent.VK_KP_DOWN, 0))
)
override val keyStrokesSet: Set<List<KeyStroke>> = setOf(
listOf(KeyStroke.getKeyStroke(KeyEvent.VK_DOWN, 0)),
listOf(KeyStroke.getKeyStroke(KeyEvent.VK_KP_DOWN, 0))
)
override val type: Command.Type = Command.Type.INSERT
override val type: Command.Type = Command.Type.INSERT
override val flags: EnumSet<CommandFlags> = enumSetOf(CommandFlags.FLAG_CLEAR_STROKES)
override val flags: EnumSet<CommandFlags> = enumSetOf(CommandFlags.FLAG_CLEAR_STROKES)
override fun execute(editor: Editor, context: DataContext, cmd: Command): Boolean {
KeyHandler.executeAction(actionName, context)
return true
}
}
}
class VimEditorTab : NativeAction() {
override val actionName: String = "EditorTab"
class VimEditorTab : VimCommandAction() {
override fun makeActionHandler(): VimActionHandler = object : VimActionHandler.SingleExecution() {
val actionName: String = "EditorTab"
override val mappingModes: Set<MappingMode> = MappingMode.I
override val mappingModes: Set<MappingMode> = MappingMode.I
override val keyStrokesSet: Set<List<KeyStroke>> = setOf(
listOf(KeyStroke.getKeyStroke(KeyEvent.VK_I, KeyEvent.CTRL_MASK)),
listOf(KeyStroke.getKeyStroke(KeyEvent.VK_TAB, 0))
)
override val keyStrokesSet: Set<List<KeyStroke>> = setOf(
listOf(KeyStroke.getKeyStroke(KeyEvent.VK_I, KeyEvent.CTRL_MASK)),
listOf(KeyStroke.getKeyStroke(KeyEvent.VK_TAB, 0))
)
override val type: Command.Type = Command.Type.INSERT
override val type: Command.Type = Command.Type.INSERT
override val flags: EnumSet<CommandFlags> = enumSetOf(CommandFlags.FLAG_SAVE_STROKE)
override val flags: EnumSet<CommandFlags> = enumSetOf(CommandFlags.FLAG_SAVE_STROKE)
override fun execute(editor: Editor, context: DataContext, cmd: Command): Boolean {
KeyHandler.executeAction(actionName, context)
return true
}
}
}
class VimEditorUp : NativeAction() {
override val actionName: String = "EditorUp"
class VimEditorUp : VimCommandAction() {
override fun makeActionHandler(): VimActionHandler = object : VimActionHandler.SingleExecution() {
val actionName: String = "EditorUp"
override val mappingModes: Set<MappingMode> = MappingMode.I
override val mappingModes: Set<MappingMode> = MappingMode.I
override val keyStrokesSet: Set<List<KeyStroke>> = setOf(
listOf(KeyStroke.getKeyStroke(KeyEvent.VK_UP, 0)),
listOf(KeyStroke.getKeyStroke(KeyEvent.VK_KP_UP, 0))
)
override val keyStrokesSet: Set<List<KeyStroke>> = setOf(
listOf(KeyStroke.getKeyStroke(KeyEvent.VK_UP, 0)),
listOf(KeyStroke.getKeyStroke(KeyEvent.VK_KP_UP, 0))
)
override val type: Command.Type = Command.Type.INSERT
override val type: Command.Type = Command.Type.INSERT
override val flags: EnumSet<CommandFlags> = enumSetOf(CommandFlags.FLAG_CLEAR_STROKES)
override val flags: EnumSet<CommandFlags> = enumSetOf(CommandFlags.FLAG_CLEAR_STROKES)
override fun execute(editor: Editor, context: DataContext, cmd: Command): Boolean {
KeyHandler.executeAction(actionName, context)
return true
}
}
}
class VimQuickJavaDoc : NativeAction() {
override val actionName: String = "QuickJavaDoc"
class VimQuickJavaDoc : VimCommandAction() {
override fun makeActionHandler(): VimActionHandler = object : VimActionHandler.SingleExecution() {
val actionName: String = "QuickJavaDoc"
override val mappingModes: Set<MappingMode> = MappingMode.N
override val mappingModes: Set<MappingMode> = MappingMode.N
override val keyStrokesSet: Set<List<KeyStroke>> = parseKeysSet("K")
override val keyStrokesSet: Set<List<KeyStroke>> = parseKeysSet("K")
override val type: Command.Type = Command.Type.OTHER_READONLY
override val type: Command.Type = Command.Type.OTHER_READONLY
override fun execute(editor: Editor, context: DataContext, cmd: Command): Boolean {
KeyHandler.executeAction(actionName, context)
return true
}
}
}

48
src/com/maddyhome/idea/vim/action/ex/ProcessExEntryAction.java
View File

@ -43,34 +43,34 @@ public class ProcessExEntryAction extends VimCommandAction {
@Override
protected VimActionHandler makeActionHandler() {
return new VimActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.C;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<CR>", "<C-M>", String.valueOf((char)0x0a), String.valueOf((char)0x0d));
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_SELF_SYNCHRONIZED;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_COMPLETE_EX);
}
@Override
public boolean execute(@NotNull Editor editor, @NotNull DataContext context, @NotNull Command cmd) {
return VimPlugin.getProcess().processExEntry(editor, context);
}
};
}
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.C;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<CR>", "<C-M>", String.valueOf((char)0x0a), String.valueOf((char)0x0d));
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_SELF_SYNCHRONIZED;
}
@NotNull
@Override
public EnumSet<CommandFlags> getFlags() {
return EnumSet.of(CommandFlags.FLAG_COMPLETE_EX);
}
}

36
src/com/maddyhome/idea/vim/action/file/FileGetAsciiAction.java
View File

@ -33,28 +33,28 @@ import java.util.Set;
public class FileGetAsciiAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("ga");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_READONLY;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new VimActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("ga");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_READONLY;
}
@Override
public boolean execute(@NotNull Editor editor, @NotNull DataContext context, @NotNull Command cmd) {
VimPlugin.getFile().displayAsciiInfo(editor);

36
src/com/maddyhome/idea/vim/action/file/FileGetFileInfoAction.java
View File

@ -33,28 +33,28 @@ import java.util.Set;
public class FileGetFileInfoAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-G>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_READONLY;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new VimActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("<C-G>");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_READONLY;
}
@Override
public boolean execute(@NotNull Editor editor, @NotNull DataContext context, @NotNull Command cmd) {
VimPlugin.getFile().displayFileInfo(editor, cmd.getRawCount() > 0);

36
src/com/maddyhome/idea/vim/action/file/FileGetHexAction.java
View File

@ -32,28 +32,28 @@ import java.util.List;
import java.util.Set;
public class FileGetHexAction extends VimCommandAction {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("g8");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_READONLY;
}
@NotNull
@Override
protected VimActionHandler makeActionHandler() {
return new VimActionHandler.SingleExecution() {
@NotNull
@Override
public Set<MappingMode> getMappingModes() {
return MappingMode.N;
}
@NotNull
@Override
public Set<List<KeyStroke>> getKeyStrokesSet() {
return parseKeysSet("g8");
}
@NotNull
@Override
public Command.Type getType() {
return Command.Type.OTHER_READONLY;
}
@Override
public boolean execute(@NotNull Editor editor, @NotNull DataContext context, @NotNull Command cmd) {
VimPlugin.getFile().displayHexInfo(editor);

Some files were not shown because too many files have changed in this diff Show More