private void OnSettingChanged(IVimBuffer buffer, Setting args)
{
if (args.Name == WindowSettingNames.CursorLineName && buffer.TextView.Options != null)
{
buffer.TextView.Options.SetOptionValue(DefaultWpfViewOptions.EnableHighlightCurrentLineId, buffer.WindowSettings.CursorLine);
}
}
protected VimMouseProcessorTest()
{
_vimBuffer = CreateVimBuffer("");
_keyboardDevice = new Mock<IKeyboardDevice>(MockBehavior.Loose);
_keyboardDevice.SetupGet(x => x.KeyModifiers).Returns(VimKeyModifiers.None);
_vimMouseProcessor = new VimMouseProcessor(_vimBuffer, _keyboardDevice.Object);
}
internal CommandMarginController(IVimBuffer buffer, FrameworkElement parentVisualElement, CommandMarginControl control, IEditorFormatMap editorFormatMap, IFontProperties fontProperties, IEnumerable<Lazy<IOptionsProviderFactory>> optionsProviderFactory)
{
_vimBuffer = buffer;
_margin = control;
_parentVisualElement = parentVisualElement;
_editorFormatMap = editorFormatMap;
_fontProperties = fontProperties;
_optionsProviderFactory = optionsProviderFactory.ToList().AsReadOnly();
_vimBuffer.SwitchedMode += OnSwitchMode;
_vimBuffer.KeyInputStart += OnKeyInputStart;
_vimBuffer.KeyInputEnd += OnKeyInputEnd;
_vimBuffer.StatusMessage += OnStatusMessage;
_vimBuffer.ErrorMessage += OnErrorMessage;
_vimBuffer.WarningMessage += OnWarningMessage;
_vimBuffer.CommandMode.CommandChanged += OnCommandChanged;
_vimBuffer.Vim.MacroRecorder.RecordingStarted += OnRecordingStarted;
_vimBuffer.Vim.MacroRecorder.RecordingStopped += OnRecordingStopped;
_margin.Loaded += OnCommandMarginLoaded;
_margin.Unloaded += OnCommandMarginUnloaded;
_margin.OptionsButton.Click += OnOptionsClicked;
_margin.CommandLineTextBox.PreviewKeyDown += OnCommandLineTextBoxPreviewKeyDown;
_margin.CommandLineTextBox.TextChanged += OnCommandLineTextBoxTextChanged;
_margin.CommandLineTextBox.SelectionChanged += OnCommandLineTextBoxSelectionChanged;
_margin.CommandLineTextBox.LostKeyboardFocus += OnCommandLineTextBoxLostKeyboardFocus;
_margin.CommandLineTextBox.PreviewMouseDown += OnCommandLineTextBoxPreviewMouseDown;
_editorFormatMap.FormatMappingChanged += OnFormatMappingChanged;
UpdateForRecordingChanged();
UpdateTextColor();
}
public void VimBufferCreated(IVimBuffer vimBuffer)
{
var taggerList = new List<ITagger<ITag>>();
var bufferAdapterList = new List<IExternalEditAdapter>();
var textView = vimBuffer.TextView;
foreach (var adapter in _adapterList)
{
ITagger<ITag> tagger;
if (adapter.IsInterested(textView, out tagger))
{
bufferAdapterList.Add(adapter);
if (tagger != null)
{
taggerList.Add(tagger);
}
}
}
if (bufferAdapterList.Count > 0)
{
_monitorMap[vimBuffer] = new ExternalEditMonitor(
vimBuffer,
_protectedOperations,
_vsAdapter.GetTextLines(vimBuffer.TextBuffer),
taggerList.ToReadOnlyCollectionShallow(),
bufferAdapterList.ToReadOnlyCollectionShallow());
vimBuffer.Closed += delegate { _monitorMap.Remove(vimBuffer); };
}
}
public MouseProcessor(IVimBuffer buffer, IMouseDevice mouseDevice)
{
_buffer = buffer;
_selection = buffer.TextView.Selection;
_mouseDevice = mouseDevice;
_selection.SelectionChanged += OnSelectionChanged;
}
public void CreateBuffer(params string[] lines)
{
var tuple = EditorUtil.CreateViewAndOperations(lines);
_textView = tuple.Item1;
var service = EditorUtil.FactoryService;
_buffer = service.vim.CreateBuffer(_textView);
}
internal CommandMarginController(IVimBuffer buffer, FrameworkElement parentVisualElement, CommandMarginControl control, IEditorFormatMap editorFormatMap, IEnumerable<Lazy<IOptionsProviderFactory>> optionsProviderFactory)
{
_vimBuffer = buffer;
_margin = control;
_parentVisualElement = parentVisualElement;
_editorFormatMap = editorFormatMap;
_optionsProviderFactory = optionsProviderFactory.ToList().AsReadOnly();
_vimBuffer.SwitchedMode += OnSwitchMode;
_vimBuffer.KeyInputStart += OnKeyInputStart;
_vimBuffer.KeyInputEnd += OnKeyInputEnd;
_vimBuffer.StatusMessage += OnStatusMessage;
_vimBuffer.ErrorMessage += OnErrorMessage;
_vimBuffer.WarningMessage += OnWarningMessage;
_vimBuffer.CommandMode.CommandChanged += OnCommandChanged;
_vimBuffer.Vim.MacroRecorder.RecordingStarted += OnRecordingStarted;
_vimBuffer.Vim.MacroRecorder.RecordingStopped += OnRecordingStopped;
_margin.OptionsClicked += OnOptionsClicked;
_margin.CancelCommandEdition += OnCancelCommandEdition;
_margin.RunCommandEdition += OnRunCommandEdition;
_margin.HistoryGoPrevious += OnHistoryGoPrevious;
_margin.HistoryGoNext += OnHistoryGoNext;
_editorFormatMap.FormatMappingChanged += OnFormatMappingChanged;
UpdateForRecordingChanged();
UpdateTextColor();
}
void IVimBufferCreationListener.VimBufferCreated(IVimBuffer vimBuffer)
{
// Let the command margin get into a known state before we disable it.
_vimProtectedOperations.BeginInvoke(
() => _commandMarginUtil.SetMarginVisibility(vimBuffer, _vimApplicationSettings.UseEditorCommandMargin),
DispatcherPriority.ApplicationIdle);
}
internal VsCommandFilter(IVimBuffer buffer, IVsTextView view, IServiceProvider provider)
{
_buffer = buffer;
_textView = view;
_serviceProvider = provider;
var hr = view.AddCommandFilter(this, out _nextTarget);
}
public VsCommandTargetTest()
{
_textView = CreateTextView("");
_buffer = Vim.CreateVimBuffer(_textView);
_bufferCoordinator = new VimBufferCoordinator(_buffer);
_vim = _buffer.Vim;
_factory = new MockRepository(MockBehavior.Strict);
// By default Resharper isn't loaded
_resharperUtil = _factory.Create<IResharperUtil>();
_resharperUtil.SetupGet(x => x.IsInstalled).Returns(false);
_nextTarget = _factory.Create<IOleCommandTarget>(MockBehavior.Strict);
_vsAdapter = _factory.Create<IVsAdapter>();
_vsAdapter.SetupGet(x => x.KeyboardDevice).Returns(InputManager.Current.PrimaryKeyboardDevice);
_vsAdapter.Setup(x => x.InAutomationFunction).Returns(false);
_vsAdapter.Setup(x => x.InDebugMode).Returns(false);
_vsAdapter.Setup(x => x.IsIncrementalSearchActive(It.IsAny<ITextView>())).Returns(false);
_broker = _factory.Create<IDisplayWindowBroker>(MockBehavior.Loose);
var oldCommandFilter = _nextTarget.Object;
var vsTextView = _factory.Create<IVsTextView>(MockBehavior.Loose);
vsTextView.Setup(x => x.AddCommandFilter(It.IsAny<IOleCommandTarget>(), out oldCommandFilter)).Returns(0);
var result = VsCommandTarget.Create(
_bufferCoordinator,
vsTextView.Object,
_vsAdapter.Object,
_broker.Object,
_resharperUtil.Object,
KeyUtil);
Assert.True(result.IsSuccess);
_targetRaw = result.Value;
_target = _targetRaw;
}
void IVimBufferCreationListener.VimBufferCreated(IVimBuffer vimBuffer)
{
// If the notification has occured then there is nothing else to do. We are done
if (_vimApplicationSettings.HaveNotifiedVimRcLoad)
{
return;
}
if (!_vim.VimRcState.IsLoadSucceeded)
{
return;
}
var vimRcPath = ((VimRcState.LoadSucceeded)_vim.VimRcState).Item;
if (vimRcPath.VimRcKind != VimRcKind.VimRc)
{
return;
}
var wpfTextView = vimBuffer.TextView as IWpfTextView;
if (wpfTextView == null)
{
return;
}
var linkBanner = new LinkBanner();
linkBanner.LinkAddress = "https://github.com/jaredpar/VsVim/wiki/FAQ#vimrc";
linkBanner.LinkText = "FAQ";
linkBanner.BannerText = "VsVim automatically loaded an existing _vimrc file";
_toastNotificationServiceProvider.GetToastNoficationService(wpfTextView).Display(_toastKey, linkBanner, OnToastNotificationClosed);
}
/// <summary>
/// Create a Visual Studio simulation with the specified set of lines
/// </summary>
private void CreateCore(bool simulateResharper, bool usePeekRole, params string[] lines)
{
if (usePeekRole)
{
_textBuffer = CreateTextBuffer(lines);
_textView = TextEditorFactoryService.CreateTextView(
_textBuffer,
TextEditorFactoryService.CreateTextViewRoleSet(PredefinedTextViewRoles.Document, PredefinedTextViewRoles.Editable, Constants.TextViewRoleEmbeddedPeekTextView));
}
else
{
_textView = CreateTextView(lines);
_textBuffer = _textView.TextBuffer;
}
_vimBuffer = Vim.CreateVimBuffer(_textView);
_bufferCoordinator = new VimBufferCoordinator(_vimBuffer);
_vsSimulation = new VsSimulation(
_bufferCoordinator,
simulateResharper: simulateResharper,
simulateStandardKeyMappings: false,
editorOperationsFactoryService: EditorOperationsFactoryService,
keyUtil: KeyUtil);
VimHost.TryCustomProcessFunc = (textView, insertCommand) =>
{
if (textView == _textView)
{
return _vsSimulation.VsCommandTarget.TryCustomProcess(insertCommand);
}
return false;
};
}
void IVimBufferCreationListener.VimBufferCreated(IVimBuffer vimBuffer)
{
if (!_vim.VimRcState.IsLoadSucceeded)
{
return;
}
var wpfTextView = vimBuffer.TextView as IWpfTextView;
if (wpfTextView == null)
{
return;
}
var state = ((VimRcState.LoadSucceeded)_vim.VimRcState);
// If the notification has occured then there is nothing else to do. We are done
if (!_vimApplicationSettings.HaveNotifiedVimRcLoad && state.Item1.VimRcKind == VimRcKind.VimRc)
{
var linkBanner = new LinkBanner();
linkBanner.LinkAddress = "https://github.com/jaredpar/VsVim/wiki/FAQ#vimrc";
linkBanner.LinkText = "FAQ";
linkBanner.BannerText = "VsVim automatically loaded an existing _vimrc file";
_toastNotificationServiceProvider.GetToastNoficationService(wpfTextView).Display(_notifyToastKey, linkBanner, OnNotifyClosed);
}
if (!_vimApplicationSettings.HaveNotifiedVimRcErrors && state.Item2.Length != 0)
{
var errorBanner = new ErrorBanner();
errorBanner.ViewClick += (sender, e) => OnViewClick(state.Item2);
_toastNotificationServiceProvider.GetToastNoficationService(wpfTextView).Display(_errorToastKey, errorBanner, OnErrorClosed);
}
}
public void Create(params string[] lines)
{
var tuple = EditorUtil.CreateViewAndOperations(lines);
_textView = tuple.Item1;
_textBuffer = _textView.TextBuffer;
var service = EditorUtil.FactoryService;
_buffer = service.Vim.CreateBuffer(_textView);
_buffer.ErrorMessage +=
(_, message) =>
{
if (_assertOnErrorMessage)
{
Assert.Fail("Error Message: " + message);
}
};
_buffer.WarningMessage +=
(_, message) =>
{
if (_assertOnWarningMessage)
{
Assert.Fail("Warning Message: " + message);
}
};
_keyMap = _buffer.Vim.KeyMap;
_globalSettings = _buffer.Settings.GlobalSettings;
_jumpList = _buffer.JumpList;
}
protected FallbackKeyProcessorTest(bool useVimBuffer = false)
{
_keyboardDevice = new MockKeyboardDevice();
_commands = new Mock<Commands>(MockBehavior.Strict);
_dte = new Mock<_DTE>(MockBehavior.Loose);
_dte.SetupGet(x => x.Commands).Returns(_commands.Object);
_vsShell = new Mock<IVsShell>(MockBehavior.Loose);
_removedBindingList = new List<CommandKeyBinding>();
_vimApplicationSettings = new Mock<IVimApplicationSettings>(MockBehavior.Loose);
_vimApplicationSettings
.SetupGet(x => x.RemovedBindings)
.Returns(() => _removedBindingList.AsReadOnly());
var textView = CreateTextView("");
_vimBuffer = useVimBuffer
? Vim.GetOrCreateVimBuffer(textView)
: null;
_keyProcessor = new FallbackKeyProcessor(
_vsShell.Object,
_dte.Object,
CompositionContainer.GetExportedValue<IKeyUtil>(),
_vimApplicationSettings.Object,
textView,
_vimBuffer,
new ScopeData());
}
/// <summary>
/// Compute the set of keys that conflict with and have been already been removed.
/// </summary>
internal CommandKeyBindingSnapshot CreateCommandKeyBindingSnapshot(IVimBuffer buffer)
{
// Get the list of all KeyInputs that are the first key of a VsVim command
var hashSet = new HashSet<KeyInput>(
buffer.AllModes
.Select(x => x.CommandNames)
.SelectMany(x => x)
.Where(x => x.KeyInputs.Length > 0)
.Select(x => x.KeyInputs.First()));
// Need to get the custom key bindings in the list. It's very common for users
// to use for example function keys (<F2>, <F3>, etc ...) in their mappings which
// are often bound to other Visual Studio commands.
var keyMap = buffer.Vim.KeyMap;
foreach (var keyRemapMode in KeyRemapMode.All)
{
foreach (var keyMapping in keyMap.GetKeyMappingsForMode(keyRemapMode))
{
keyMapping.Left.KeyInputs.ForEach(keyInput => hashSet.Add(keyInput));
}
}
// Include the key used to disable VsVim
hashSet.Add(buffer.LocalSettings.GlobalSettings.DisableAllCommand);
return CreateCommandKeyBindingSnapshot(hashSet);
}
protected void Create(params string[] lines)
{
_textView = CreateTextView(lines);
_vimBuffer = Vim.CreateVimBuffer(_textView);
_vimBuffer.SwitchMode(ModeKind.Normal, ModeArgument.None);
_globalSettings = _vimBuffer.LocalSettings.GlobalSettings;
VimHost.FocusedTextView = _textView;
}
private void OnSettingChanged(IVimBuffer vimBuffer, SettingEventArgs args)
{
var setting = args.Setting;
if (setting.Name == WindowSettingNames.CursorLineName)
{
SyncVimToEditor(vimBuffer);
}
}
public void Create(params string[] lines)
{
_textView = EditorUtil.CreateView(lines);
_buffer = EditorUtil.FactoryService.Vim.CreateBuffer(_textView);
_search = _buffer.IncrementalSearch;
_taggerRaw = new IncrementalSearchTagger(_buffer);
_tagger = _taggerRaw;
}
private void OnSettingChanged(IVimBuffer buffer, Setting args)
{
if (args.Name == LocalSettingNames.CursorLineName)
{
var options = _editorOptionsFatoryService.GetOptions(buffer.TextView);
options.SetOptionValue(DefaultWpfViewOptions.EnableHighlightCurrentLineId, buffer.Settings.CursorLine);
}
}
public void Create(params string[] lines)
{
_vimBuffer = CreateVimBuffer(lines);
_vimBuffer.StatusMessage += (sender, args) => { _lastStatus = args.Message; };
_textView = _vimBuffer.TextView;
_textBuffer = _textView.TextBuffer;
_vimHost = VimHost;
}
public void Setup()
{
_synchronizer = new EditorToSettingSynchronizer(EditorUtil.FactoryService.Vim);
_buffer = EditorUtil.FactoryService.Vim.CreateBuffer(EditorUtil.CreateTextView(""));
_localSettings = _buffer.LocalSettings;
_globalSettings = _localSettings.GlobalSettings;
_editorOptions = _localSettings.EditorOptions.Value;
}
public void CreateBuffer(params string[] lines)
{
var tuple = Utils.EditorUtil.CreateViewAndOperations(lines);
m_view = tuple.Item1;
var service = EditorUtil.FactoryService;
m_buffer = service.vim.CreateBuffer(m_view);
m_host = (FakeVimHost)service.vim.Host;
}
protected void Create(params string[] lines)
{
_vimBuffer = CreateVimBuffer(lines);
_textBuffer = _vimBuffer.TextBuffer;
_vimKeyProcessor = new VimKeyProcessor(_vimBuffer, KeyUtil);
_simulation = new KeyboardInputSimulation((IWpfTextView)_vimBuffer.TextView);
_simulation.KeyProcessors.Add(_vimKeyProcessor);
}
public void CreateBuffer(params string[] lines)
{
var tuple = EditorUtil.CreateViewAndOperations(lines);
_textView = tuple.Item1;
var service = EditorUtil.FactoryService;
_buffer = service.vim.CreateBuffer(_textView);
_buffer.SwitchMode(ModeKind.Insert, ModeArgument.None);
}
protected void Create(bool insertMode, params string[] lines)
{
_factory = new MockRepository(MockBehavior.Strict);
_factory.DefaultValue = DefaultValue.Mock;
_textView = CreateTextView(lines);
_textBuffer = _textView.TextBuffer;
_vim = _factory.Create<IVim>(MockBehavior.Loose);
_editorOptions = _factory.Create<IEditorOptions>(MockBehavior.Loose);
_textChangeTracker = _factory.Create<ITextChangeTracker>(MockBehavior.Loose);
_textChangeTracker.SetupGet(x => x.CurrentChange).Returns(FSharpOption<TextChange>.None);
_undoRedoOperations = CreateUndoRedoOperations();
_wordCompletionSessionFactoryService = _factory.Create<IWordCompletionSessionFactoryService>();
var localSettings = new LocalSettings(Vim.GlobalSettings);
_vimBuffer = Vim.CreateVimBuffer(_textView);
_globalSettings = _vimBuffer.GlobalSettings;
var vimTextBuffer = Vim.GetOrCreateVimTextBuffer(_textView.TextBuffer);
var vimBufferData = CreateVimBufferData(vimTextBuffer, _textView);
_operations = CommonOperationsFactory.GetCommonOperations(vimBufferData);
_broker = _factory.Create<IDisplayWindowBroker>();
_broker.SetupGet(x => x.IsCompletionActive).Returns(false);
_broker.SetupGet(x => x.IsQuickInfoActive).Returns(false);
_broker.SetupGet(x => x.IsSignatureHelpActive).Returns(false);
_broker.SetupGet(x => x.IsSmartTagSessionActive).Returns(false);
_insertUtil = _factory.Create<IInsertUtil>();
_motionUtil = _factory.Create<IMotionUtil>();
_commandUtil = _factory.Create<ICommandUtil>();
_capture = _factory.Create<IMotionCapture>();
// Setup the mouse. By default we say it has no buttons down as that's the normal state
_mouseDevice = _factory.Create<IMouseDevice>();
_mouseDevice.SetupGet(x => x.IsLeftButtonPressed).Returns(false);
// Setup the keyboard. By default we don't say that any button is pressed. Insert mode is usually
// only concerned with arrow keys and we will set those up as appropriate for the typing tests
_keyboardDevice = _factory.Create<IKeyboardDevice>();
_keyboardDevice.Setup(x => x.IsArrowKeyDown).Returns(false);
_modeRaw = new global::Vim.Modes.Insert.InsertMode(
_vimBuffer,
_operations,
_broker.Object,
_editorOptions.Object,
_undoRedoOperations,
_textChangeTracker.Object,
_insertUtil.Object,
_motionUtil.Object,
_commandUtil.Object,
_capture.Object,
!insertMode,
_keyboardDevice.Object,
_mouseDevice.Object,
WordUtil,
_wordCompletionSessionFactoryService.Object);
_mode = _modeRaw;
_mode.OnEnter(ModeArgument.None);
_mode.CommandRan += (sender, e) => { _lastCommandRan = e.CommandRunData; };
}
public void CreateBuffer(params string[] lines)
{
var tuple = EditorUtil.CreateViewAndOperations(lines);
view = tuple.Item1;
host = new MockVimHost();
var service = EditorUtil.FactoryService;
buffer = service.vim.CreateBuffer(view);
host = (MockVimHost)service.vim.VimHost;
}
private void Create(params string[] lines)
{
_globalSettings = Vim.GlobalSettings;
_vimBuffer = CreateVimBuffer(lines);
_textView = (IWpfTextView)_vimBuffer.TextView;
_textBuffer = _vimBuffer.TextBuffer;
_commonOperationsRaw = (CommonOperations)CommonOperationsFactory.GetCommonOperations(_vimBuffer.VimBufferData);
_commonOperations = _commonOperationsRaw;
}
void IVimBufferCreationListener.VimBufferCreated(IVimBuffer buffer)
{
var textView = buffer.TextView;
textView.Closed += (x, y) =>
{
buffer.Close();
_bufferMap.Remove(buffer);
};
}
internal static string GetStatus(IVimBuffer vimBuffer, IMode currentMode, bool forModeSwitch)
{
if (forModeSwitch)
{
return GetStatusCommon(vimBuffer, currentMode);
}
return GetStatusOther(vimBuffer, currentMode);
}
public static Register GetRegister(this IVimBuffer buffer, char c)
{
var name = RegisterNameUtil.CharToRegister(c).Value;
return(buffer.RegisterMap.GetRegister(name));
}
public SettingsTest()
{
_vimBuffer = CreateVimBuffer("hello world");
_textView = _vimBuffer.TextView;
}
public static bool Process(this IVimBuffer buf, char c)
{
return(buf.Process(KeyInputUtil.CharToKeyInput(c)).IsAnyHandled);
}
public DisabledModeIntegrationTest()
{
_vimBuffer1 = CreateVimBuffer("vim buffer 1");
_vimBuffer2 = CreateVimBuffer("vim buffer 2");
}
void ICSharpScriptExecutor.Execute(IVimBuffer vimBuffer, CallInfo callInfo, bool createEachTime)
{
var task = ExecuteAsync(vimBuffer, callInfo, createEachTime);
VimTrace.TraceInfo("CSharptScript:Execute {0}", callInfo.Name);
}
string ICommandMarginUtil.GetStatus(IVimBuffer vimBuffer)
{
return(GetStatus(vimBuffer, vimBuffer.Mode, forModeSwitch: false));
}
CommandKeyBindingSnapshot IKeyBindingService.CreateCommandKeyBindingSnapshot(IVimBuffer vimBuffer)
{
return(CreateCommandKeyBindingSnapshot(vimBuffer));
}
protected virtual void Create(params string[] lines)
{
_vimBuffer = CreateVimBuffer(lines);
_textView = _vimBuffer.TextView;
_textBuffer = _textView.TextBuffer;
}
public CommandMargin(IVimBuffer buffer, IEditorFormatMap editorFormatMap, IEnumerable <Lazy <IOptionsProviderFactory> > optionsProviderFactories)
{
_margin.StatusLine = "Welcome to Vim";
_controller = new CommandMarginController(buffer, _margin, editorFormatMap, optionsProviderFactories);
}
void IVimBufferCreationListener.VimBufferCreated(IVimBuffer vimBuffer)
{
OnVimBufferCreated(vimBuffer);
}
internal void AddViewInfo(IVimBuffer vimBuffer, IWpfTextViewHost textViewHost)
{
_viewInfoList.Add(new ViewInfo(vimBuffer, textViewHost));
}
protected void UpdateTabStop(IVimBuffer vimBuffer, int tabStop)
{
vimBuffer.LocalSettings.TabStop = tabStop;
vimBuffer.LocalSettings.ExpandTab = false;
UpdateLayout(vimBuffer.TextView);
}
public static bool Process(this IVimBuffer buf, VimKey key)
{
return(buf.Process(KeyInputUtil.VimKeyToKeyInput(key)));
}
private ReSharperKeyUtil(IVimBufferCoordinator vimBufferCoordinator)
{
_vimBufferCoordinator = vimBufferCoordinator;
_vimBuffer = vimBufferCoordinator.VimBuffer;
}
private static string GetStatusCommon(IVimBuffer vimBuffer, IMode currentMode)
{
// Calculate the argument string if we are in one time command mode
string oneTimeArgument = null;
if (vimBuffer.InOneTimeCommand.IsSome())
{
if (vimBuffer.InOneTimeCommand.Is(ModeKind.Insert))
{
oneTimeArgument = "insert";
}
else if (vimBuffer.InOneTimeCommand.Is(ModeKind.Replace))
{
oneTimeArgument = "replace";
}
}
// Check if we can enable the command line to accept user input
var search = vimBuffer.IncrementalSearch;
string status;
switch (currentMode.ModeKind)
{
case ModeKind.Normal:
status = string.IsNullOrEmpty(oneTimeArgument)
? string.Empty
: string.Format(Resources.NormalOneTimeCommandBanner, oneTimeArgument);
break;
case ModeKind.Command:
status = ":" + vimBuffer.CommandMode.Command;
break;
case ModeKind.Insert:
status = Resources.InsertBanner;
break;
case ModeKind.Replace:
status = Resources.ReplaceBanner;
break;
case ModeKind.VisualBlock:
status = string.IsNullOrEmpty(oneTimeArgument)
? Resources.VisualBlockBanner
: string.Format(Resources.VisualBlockOneTimeCommandBanner, oneTimeArgument);
break;
case ModeKind.VisualCharacter:
status = string.IsNullOrEmpty(oneTimeArgument)
? Resources.VisualCharacterBanner
: string.Format(Resources.VisualCharacterOneTimeCommandBanner, oneTimeArgument);
break;
case ModeKind.VisualLine:
status = string.IsNullOrEmpty(oneTimeArgument)
? Resources.VisualLineBanner
: string.Format(Resources.VisualLineOneTimeCommandBanner, oneTimeArgument);
break;
case ModeKind.SelectBlock:
status = Resources.SelectBlockBanner;
break;
case ModeKind.SelectCharacter:
status = Resources.SelectCharacterBanner;
break;
case ModeKind.SelectLine:
status = Resources.SelectLineBanner;
break;
case ModeKind.ExternalEdit:
status = Resources.ExternalEditBanner;
break;
case ModeKind.Disabled:
status = vimBuffer.DisabledMode.HelpMessage;
break;
case ModeKind.SubstituteConfirm:
status = GetStatusSubstituteConfirm(vimBuffer.SubstituteConfirmMode);
break;
default:
status = string.Empty;
break;
}
return(status);
}
public static BlockSpan GetSelectionBlockSpan(this IVimBuffer vimBuffer)
{
return(GetSelectionBlockSpan(vimBuffer.TextView, vimBuffer.LocalSettings.TabStop));
}
void ICommandMarginUtil.SetMarginVisibility(IVimBuffer vimBuffer, bool commandMarginVisible)
{
SetMarginVisibility(vimBuffer, commandMarginVisible);
}
public static BlockSpan GetBlockSpan(this IVimBuffer vimBuffer, int column, int length, int startLine = 0, int lineCount = 1)
{
return(GetBlockSpan(vimBuffer.TextBuffer, column, length, startLine, lineCount, vimBuffer.LocalSettings.TabStop));
}
/// <summary>
/// Compute the set of keys that conflict with and have been already been removed.
/// </summary>
internal CommandKeyBindingSnapshot CreateCommandKeyBindingSnapshot(IVimBuffer vimBuffer)
{
var hashSet = CreateVimFirstKeyInputSet(vimBuffer);
return(CreateCommandKeyBindingSnapshot(hashSet));
}
public void RunCSharpScript(IVimBuffer vimBuffer, CallInfo callInfo, bool createEachTime)
{
throw new NotImplementedException();
}
void IKeyBindingService.RunConflictingKeyBindingStateCheck(IVimBuffer buffer)
{
RunConflictingKeyBindingStateCheck(buffer);
}
void IVimBufferCreationListener.VimBufferCreated(IVimBuffer vimBuffer)
{
Count++;
VimBuffer = vimBuffer;
}
public VimKeyProcessor(IVimBuffer vimBuffer, IKeyUtil keyUtil)
{
_vimBuffer = vimBuffer;
_keyUtil = keyUtil;
}
protected VimMouseProcessorTest()
{
_vimBuffer = CreateVimBuffer("");
_vimMouseProcessor = new VimMouseProcessor(_vimBuffer);
}
internal ViewInfo(IVimBuffer vimBuffer, IWpfTextViewHost textViewHost)
{
_vimBuffer = vimBuffer;
_textViewHost = textViewHost;
}
public CommandMargin(FrameworkElement parentVisualElement, IVimBuffer buffer, IEditorFormatMap editorFormatMap, IClassificationFormatMap classificationFormatMap, ICommonOperations commonOperations, IClipboardDevice clipboardDevice, bool isFirstCommandMargin)
{
_margin.CommandLineTextBox.Text = isFirstCommandMargin ? $"Welcome to VsVim Version {VimConstants.VersionNumber}" : string.Empty;
_controller = new CommandMarginController(buffer, parentVisualElement, _margin, editorFormatMap, classificationFormatMap, commonOperations, clipboardDevice);
_enabled = true;
}
internal VimMouseProcessor(IVimBuffer vimBuffer)
{
_vimBuffer = vimBuffer;
}
/// <summary>
/// Helper for the CanProcessAsCommand function which maps the char to a KeyInput value
/// </summary>
public static bool CanProcessAsCommand(this IVimBuffer buffer, char c)
{
var keyInput = KeyInputUtil.CharToKeyInput(c);
return(buffer.CanProcessAsCommand(keyInput));
}
/// <summary>
/// Helper for the CanProcessAsCommand function which maps the VimKey to a KeyInput value
/// </summary>
public static bool CanProcessAsCommand(this IVimBuffer buffer, VimKey key)
{
var keyInput = KeyInputUtil.VimKeyToKeyInput(key);
return(buffer.CanProcessAsCommand(keyInput));
}
private void RaiseVimBufferCreated(IVimBuffer vimBuffer)
{
var listener = (IVimBufferCreationListener)_hostFactory;
listener.VimBufferCreated(vimBuffer);
}
