private bool ParseArguments(IInteractiveWindow window, string arguments, out string commandName, out IInteractiveWindowCommand command) { string name = arguments.Split(s_whitespaceChars)[0]; if (name.Length == 0) { command = null; commandName = null; return true; } var commands = window.GetInteractiveCommands(); string prefix = commands.CommandPrefix; // display help on a particular command: command = commands[name]; if (command == null && name.StartsWith(prefix, StringComparison.Ordinal)) { name = name.Substring(prefix.Length); command = commands[name]; } commandName = name; return command != null; }
internal Task Execute(IInteractiveWindow interactiveWindow, string title) { ImmutableArray<string> references, referenceSearchPaths, sourceSearchPaths, namespacesToImport; string projectDirectory; if (GetProjectProperties(out references, out referenceSearchPaths, out sourceSearchPaths, out namespacesToImport, out projectDirectory)) { // Now, we're going to do a bunch of async operations. So create a wait // indicator so the user knows something is happening, and also so they cancel. var waitIndicator = GetWaitIndicator(); var waitContext = waitIndicator.StartWait(title, InteractiveEditorFeaturesResources.BuildingProject, allowCancel: true); var resetInteractiveTask = ResetInteractiveAsync( interactiveWindow, references, referenceSearchPaths, sourceSearchPaths, namespacesToImport, projectDirectory, waitContext); // Once we're done resetting, dismiss the wait indicator and focus the REPL window. return resetInteractiveTask.SafeContinueWith( _ => { waitContext.Dispose(); ExecutionCompleted?.Invoke(this, new EventArgs()); }, TaskScheduler.FromCurrentSynchronizationContext()); } return Task.CompletedTask; }
public VsInteractiveWindowCommandFilter(IVsEditorAdaptersFactoryService adapterFactory, IInteractiveWindow window, IVsTextView textViewAdapter, IVsTextBuffer bufferAdapter, IEnumerable<Lazy<IVsInteractiveWindowOleCommandTargetProvider, ContentTypeMetadata>> oleCommandTargetProviders, IContentTypeRegistryService contentTypeRegistry) { _window = window; _oleCommandTargetProviders = oleCommandTargetProviders; _contentTypeRegistry = contentTypeRegistry; this.textViewAdapter = textViewAdapter; // make us a code window so we'll have the same colors as a normal code window. IVsTextEditorPropertyContainer propContainer; ErrorHandler.ThrowOnFailure(((IVsTextEditorPropertyCategoryContainer)textViewAdapter).GetPropertyCategory(Microsoft.VisualStudio.Editor.DefGuidList.guidEditPropCategoryViewMasterSettings, out propContainer)); propContainer.SetProperty(VSEDITPROPID.VSEDITPROPID_ViewComposite_AllCodeWindowDefaults, true); propContainer.SetProperty(VSEDITPROPID.VSEDITPROPID_ViewGlobalOpt_AutoScrollCaretOnTextEntry, true); // editor services are initialized in textViewAdapter.Initialize - hook underneath them: _preEditorCommandFilter = new CommandFilter(this, CommandFilterLayer.PreEditor); ErrorHandler.ThrowOnFailure(textViewAdapter.AddCommandFilter(_preEditorCommandFilter, out _editorCommandFilter)); textViewAdapter.Initialize( (IVsTextLines)bufferAdapter, IntPtr.Zero, (uint)TextViewInitFlags.VIF_HSCROLL | (uint)TextViewInitFlags.VIF_VSCROLL | (uint)TextViewInitFlags3.VIF_NO_HWND_SUPPORT, new[] { new INITVIEW { fSelectionMargin = 0, fWidgetMargin = 0, fVirtualSpace = 0, fDragDropMove = 1 } }); // disable change tracking because everything will be changed var textViewHost = adapterFactory.GetWpfTextViewHost(textViewAdapter); _preLanguageCommandFilter = new CommandFilter(this, CommandFilterLayer.PreLanguage); ErrorHandler.ThrowOnFailure(textViewAdapter.AddCommandFilter(_preLanguageCommandFilter, out _editorServicesCommandFilter)); _textViewHost = textViewHost; }
public Task<ExecutionResult> Execute(IInteractiveWindow window, string arguments) { var engine = window.Evaluator as InteractiveEvaluator; if (engine != null) { int i = 0; string path; if (!CommandArgumentsParser.ParsePath(arguments, ref i, out path) || path == null) { ReportInvalidArguments(window); return ExecutionResult.Failed; } if (!CommandArgumentsParser.ParseTrailingTrivia(arguments, ref i)) { window.ErrorOutputWriter.WriteLine(string.Format(EditorFeaturesResources.UnexpectedText, arguments.Substring(i))); return ExecutionResult.Failed; } return engine.LoadCommandAsync(path); } return ExecutionResult.Failed; }
public Task<ExecutionResult> Execute(IInteractiveWindow window, string arguments) { var eval = window.GetPythonDebugReplEvaluator(); if (eval != null) { eval.DisplayProcesses(); } return ExecutionResult.Succeeded; }
public Task<ExecutionResult> Execute(IInteractiveWindow window, string arguments) { var eval = window.Evaluator as PythonDebugReplEvaluator; if (eval != null) { eval.StepInto(); } return ExecutionResult.Succeeded; }
public Task<ExecutionResult> Execute(IReplWindow window, string arguments) { var eval = window.Evaluator as JReplEvaluator; if (eval != null) { if (eval.AttachEnabled) { string error = eval.AttachDebugger(); if (error != null) { window.WriteError("Failed to attach: " + error); } } else { window.WriteError( "Attaching to an interactive window requires enabling attach " + "support in Tools->Options->J Tools->Interactive Windows." + Environment.NewLine + Environment.NewLine + "This will cause the debugger to track necessary state to enable " + "debugging until the attach is requested. Once enabled the " + "interactive window will need to be reset for the change to take " + "effect."); } } else { window.WriteError("attach only supports J interactive windows"); } return ExecutionResult.Succeeded; }
IWpfTextView IInteractiveWindowEditorFactoryService.CreateTextView(IInteractiveWindow window, ITextBuffer buffer, ITextViewRoleSet roles) { WpfTestCase.RequireWpfFact($"Creates an IWpfTextView in {nameof(InteractiveWindowEditorsFactoryService)}"); var textView = _textEditorFactoryService.CreateTextView(buffer, roles); return _textEditorFactoryService.CreateTextViewHost(textView, false).TextView; }
public void Initialize() { // We have to show the window at least once to ensure the interactive service is loaded. ShowWindow(waitForPrompt: false); CloseWindow(); _interactiveWindow = AcquireInteractiveWindow(); }
public Task<ExecutionResult> Execute(IReplWindow window, string arguments) { var remoteEval = window.Evaluator as IMultipleScopeEvaluator; if (remoteEval != null) { remoteEval.SetScope(arguments); } return ExecutionResult.Succeeded; }
public Task<ExecutionResult> Execute(IInteractiveWindow window, string arguments) { var remoteEval = window.Evaluator as IMultipleScopeEvaluator; Debug.Assert(remoteEval != null, "Evaluator does not support switching scope"); if (remoteEval != null) { remoteEval.SetScope(arguments); } return ExecutionResult.Succeeded; }
public Task<ExecutionResult> Execute(IReplWindow window, string arguments) { var eval = window.Evaluator as JDebugReplEvaluator; if (eval != null) { eval.DisplayProcesses(); } return ExecutionResult.Succeeded; }
ITextBuffer IInteractiveWindowEditorFactoryService.CreateAndActivateBuffer(IInteractiveWindow window) { IContentType contentType; if (!window.Properties.TryGetProperty(typeof(IContentType), out contentType)) { contentType = _contentTypeRegistry.GetContentType(ContentType); } return _textBufferFactoryService.CreateTextBuffer(contentType); }
public IWpfTextViewHost GetTextViewHost(IInteractiveWindow window) { var cmdFilter = GetCommandFilter(window); if (cmdFilter != null) { return cmdFilter.TextViewHost; } return null; }
public RInteractiveWindowVisualComponent(IInteractiveWindow interactiveWindow, IVisualComponentContainer<IInteractiveWindowVisualComponent> container) { InteractiveWindow = interactiveWindow; Container = container; var textView = interactiveWindow.TextView; Controller = ServiceManagerBase.GetService<ICommandTarget>(textView); Control = textView.VisualElement; interactiveWindow.Properties.AddProperty(typeof(IInteractiveWindowVisualComponent), this); }
public TestInteractiveCommandHandler( IInteractiveWindow interactiveWindow, IContentTypeRegistryService contentTypeRegistryService, IEditorOptionsFactoryService editorOptionsFactoryService, IEditorOperationsFactoryService editorOperationsFactoryService) : base(contentTypeRegistryService, editorOptionsFactoryService, editorOperationsFactoryService) { _interactiveWindow = interactiveWindow; }
public MockInteractiveWindowCommands( IInteractiveWindow window, string prefix, IEnumerable<IInteractiveWindowCommand> commands ) { CommandPrefix = prefix; _window = window; _commands = commands.ToList(); }
public Task<ExecutionResult> Execute(IReplWindow window, string arguments) { arguments = arguments.ToLowerInvariant(); if (arguments == "on") { window.SetOptionValue(ReplOptions.ShowOutput, true); } else { window.SetOptionValue(ReplOptions.ShowOutput, false); } return ExecutionResult.Succeeded; }
public RSessionCallback(IInteractiveWindow interactiveWindow, IRSession session, IRSettings settings, ICoreShell coreShell, IFileSystem fileSystem) { _interactiveWindow = interactiveWindow; _session = session; _settings = settings; _coreShell = coreShell; _fileSystem = fileSystem; var workflowProvider = _coreShell.ExportProvider.GetExportedValue<IRInteractiveWorkflowProvider>(); _workflow = workflowProvider.GetOrCreate(); }
private async Task ResetInteractiveAsync( IInteractiveWindow interactiveWindow, ImmutableArray<string> referencePaths, ImmutableArray<string> referenceSearchPaths, ImmutableArray<string> sourceSearchPaths, ImmutableArray<string> projectNamespaces, string projectDirectory, IWaitContext waitContext) { // First, open the repl window. IInteractiveEvaluator evaluator = interactiveWindow.Evaluator; // If the user hits the cancel button on the wait indicator, then we want to stop the // build. using (waitContext.CancellationToken.Register(() => CancelBuildProject(), useSynchronizationContext: true)) { // First, start a build. // If the build fails do not reset the REPL. var builtSuccessfully = await BuildProject().ConfigureAwait(true); if (!builtSuccessfully) { return; } } // Then reset the REPL waitContext.Message = InteractiveEditorFeaturesResources.Resetting_Interactive; await interactiveWindow.Operations.ResetAsync(initialize: true).ConfigureAwait(true); // TODO: load context from an rsp file. // Now send the reference paths we've collected to the repl. // The SetPathsAsync method is not available through an Interface. // Execute the method only if the cast to a concrete InteractiveEvaluator succeeds. InteractiveEvaluator interactiveEvaluator = evaluator as InteractiveEvaluator; if (interactiveEvaluator != null) { await interactiveEvaluator.SetPathsAsync(referenceSearchPaths, sourceSearchPaths, projectDirectory).ConfigureAwait(true); } var editorOptions = _editorOptionsFactoryService.GetOptions(interactiveWindow.CurrentLanguageBuffer); var importReferencesCommand = referencePaths.Select(_createReference); await interactiveWindow.SubmitAsync(importReferencesCommand).ConfigureAwait(true); // Project's default namespace might be different from namespace used within project. // Filter out namespace imports that do not exist in interactive compilation. IEnumerable<string> namespacesToImport = await GetNamespacesToImportAsync(projectNamespaces, interactiveWindow).ConfigureAwait(true); var importNamespacesCommand = namespacesToImport.Select(_createImport).Join(editorOptions.GetNewLineCharacter()); if (!string.IsNullOrWhiteSpace(importNamespacesCommand)) { await interactiveWindow.SubmitAsync(new[] { importNamespacesCommand }).ConfigureAwait(true); } }
public Task<ExecutionResult> Execute(IInteractiveWindow window, string arguments) { bool initialize; if (!TryParseArguments(arguments, out initialize)) { ReportInvalidArguments(window); return ExecutionResult.Failed; } return window.Operations.ResetAsync(initialize); }
public TestInteractiveCommandHandler( IInteractiveWindow interactiveWindow, IContentTypeRegistryService contentTypeRegistryService, IEditorOptionsFactoryService editorOptionsFactoryService, IEditorOperationsFactoryService editorOperationsFactoryService, IWaitIndicator waitIndicator) : base(contentTypeRegistryService, editorOptionsFactoryService, editorOperationsFactoryService, waitIndicator) { _interactiveWindow = interactiveWindow; _sendToInteractiveSubmissionProvider = new CSharpSendToInteractiveSubmissionProvider(); }
public override Task<ExecutionResult> Execute(IInteractiveWindow window, string arguments) { int noConfigStart, noConfigEnd; if (!TryParseArguments(arguments, out noConfigStart, out noConfigEnd)) { ReportInvalidArguments(window); return ExecutionResult.Failed; } return ((InteractiveWindow)window).ResetAsync(initialize: noConfigStart > -1); }
public IInteractiveWindowCommands CreateInteractiveCommands( IInteractiveWindow window, string prefix, IEnumerable<IInteractiveWindowCommand> commands ) { return window.Properties.GetOrCreateSingletonProperty(() => new MockInteractiveWindowCommands( window, prefix, commands )); }
internal InteractiveWindowTestHost() { _exportProvider = new CompositionContainer( s_lazyCatalog.Value, CompositionOptions.DisableSilentRejection | CompositionOptions.IsThreadSafe); var contentTypeRegistryService = _exportProvider.GetExport<IContentTypeRegistryService>().Value; Evaluator = new TestInteractiveEvaluator(); Window = _exportProvider.GetExport<IInteractiveWindowFactoryService>().Value.CreateWindow(Evaluator); Window.InitializeAsync().Wait(); }
internal InteractiveWindowTestHost(Action<InteractiveWindow.State> stateChangedHandler = null) { ExportProvider = new CompositionContainer( s_lazyCatalog.Value, CompositionOptions.DisableSilentRejection | CompositionOptions.IsThreadSafe); var contentTypeRegistryService = ExportProvider.GetExport<IContentTypeRegistryService>().Value; Evaluator = new TestInteractiveEngine(contentTypeRegistryService); Window = ExportProvider.GetExport<IInteractiveWindowFactoryService>().Value.CreateWindow(Evaluator); ((InteractiveWindow)Window).StateChanged += stateChangedHandler; Window.InitializeAsync().Wait(); }
IWpfTextView IInteractiveWindowEditorFactoryService.CreateTextView(IInteractiveWindow window, ITextBuffer buffer, ITextViewRoleSet roles) { var bufferAdapter = _adapterFactory.CreateVsTextBufferAdapterForSecondaryBuffer(_provider, buffer); // Create and initialize text view adapter. // WARNING: This might trigger various services like IntelliSense, margins, taggers, etc. var textViewAdapter = _adapterFactory.CreateVsTextViewAdapter(_provider, roles); var commandFilter = new VsInteractiveWindowCommandFilter(_adapterFactory, window, textViewAdapter, bufferAdapter, _oleCommandTargetProviders, _contentTypeRegistry); window.Properties[typeof(VsInteractiveWindowCommandFilter)] = commandFilter; return commandFilter.TextViewHost.TextView; }
public override Task<ExecutionResult> Execute(IInteractiveWindow window, string arguments) { int noConfigStart, noConfigEnd; bool? init = ParseArguments(arguments, out noConfigStart, out noConfigEnd); if (init == null) { ReportInvalidArguments(window); return ExecutionResult.Failed; } return ((InteractiveWindow)window).ResetAsync(init.Value); }
internal InteractiveWindowTestHost(Action<InteractiveWindow.State> stateChangedHandler = null) { SynchronizationContext.SetSynchronizationContext(new DispatcherSynchronizationContext()); _exportProvider = new CompositionContainer( _lazyCatalog.Value, CompositionOptions.DisableSilentRejection | CompositionOptions.IsThreadSafe); var contentTypeRegistryService = _exportProvider.GetExport<IContentTypeRegistryService>().Value; _window = _exportProvider.GetExport<IInteractiveWindowFactoryService>().Value.CreateWindow(new TestInteractiveEngine(contentTypeRegistryService)); ((InteractiveWindow)_window).StateChanged += stateChangedHandler; _window.InitializeAsync().PumpingWait(); }
public InteractiveWindowTestHost() { SynchronizationContext.SetSynchronizationContext(new DispatcherSynchronizationContext()); var types = new[] { typeof(TestInteractiveEngine), typeof(InteractiveWindow) }.Concat(GetVisualStudioTypes()); _exportProvider = new CompositionContainer( new AggregateCatalog(types.Select(t => new AssemblyCatalog(t.Assembly))), CompositionOptions.DisableSilentRejection | CompositionOptions.IsThreadSafe); var contentTypeRegistryService = _exportProvider.GetExport<IContentTypeRegistryService>().Value; _window = _exportProvider.GetExport<IInteractiveWindowFactoryService>().Value.CreateWindow(new TestInteractiveEngine(contentTypeRegistryService)); _window.InitializeAsync().PumpingWait(); }
internal Commands(IInteractiveWindow window, string prefix, IEnumerable <IInteractiveWindowCommand> commands, IContentTypeRegistryService contentTypeRegistry = null, IStandardClassificationService classificationRegistry = null) { CommandPrefix = prefix; _window = window; Dictionary <string, IInteractiveWindowCommand> commandsDict = new Dictionary <string, IInteractiveWindowCommand>(); foreach (var command in commands) { int length = 0; foreach (var name in command.Names) { if (commandsDict.ContainsKey(name)) { throw new InvalidOperationException(string.Format(InteractiveWindowResources.DuplicateCommand, string.Join(", ", command.Names))); } if (length != 0) { length += _commandSeparator.Length; } length += name.Length; commandsDict[name] = command; } if (length == 0) { throw new InvalidOperationException(string.Format(InteractiveWindowResources.MissingCommandName, command.GetType().Name)); } _maxCommandNameLength = Math.Max(_maxCommandNameLength, length); } _commands = commandsDict; _classificationRegistry = classificationRegistry; if (contentTypeRegistry != null) { _commandContentType = contentTypeRegistry.GetContentType(PredefinedInteractiveCommandsContentTypes.InteractiveCommandContentTypeName); } if (window != null) { window.SubmissionBufferAdded += Window_SubmissionBufferAdded; window.Properties[typeof(IInteractiveWindowCommands)] = this; } }
ITextBuffer IInteractiveWindowEditorFactoryService.CreateAndActivateBuffer(IInteractiveWindow window, IContentType contentType) { // create buffer adapter to support undo/redo: var bufferAdapter = _adapterFactory.CreateVsTextBufferAdapter(_provider, contentType); bufferAdapter.InitializeContent("", 0); var commandFilter = GetCommandFilter(window); if (commandFilter.currentBufferCommandHandler != null) { ((IVsPersistDocData)commandFilter.currentBufferCommandHandler).Close(); } commandFilter.currentBufferCommandHandler = (IOleCommandTarget)bufferAdapter; return(_adapterFactory.GetDocumentBuffer(bufferAdapter)); }
private static void AppendTextWithEscapes( IInteractiveWindow window, string text, bool addNewLine, bool isError ) { int start = 0, escape = text.IndexOf("\x1b["); var colors = window.OutputBuffer.Properties.GetOrCreateSingletonProperty( ReplOutputClassifier.ColorKey, () => new List <ColoredSpan>() ); ConsoleColor?color = null; Span span; var write = isError ? (Func <string, Span>)window.WriteError : window.Write; while (escape >= 0) { span = write(text.Substring(start, escape - start)); if (span.Length > 0) { colors.Add(new ColoredSpan(span, color)); } start = escape + 2; color = GetColorFromEscape(text, ref start); escape = text.IndexOf("\x1b[", start); } var rest = text.Substring(start); if (addNewLine) { rest += Environment.NewLine; } span = write(rest); if (span.Length > 0) { colors.Add(new ColoredSpan(span, color)); } }
private ReplEditFilter( IVsTextView vsTextView, ITextView textView, IEditorOperations editorOps, IServiceProvider serviceProvider, IOleCommandTarget next ) { _vsTextView = vsTextView; _textView = textView; _editorOps = editorOps; _serviceProvider = serviceProvider; _componentModel = _serviceProvider.GetComponentModel(); _pyService = _serviceProvider.GetPythonToolsService(); _interactive = _textView.TextBuffer.GetInteractiveWindow(); _next = next; if (_interactive != null) { _selectEval = _interactive.Evaluator as SelectableReplEvaluator; } if (_selectEval != null) { _selectEval.EvaluatorChanged += EvaluatorChanged; _selectEval.AvailableEvaluatorsChanged += AvailableEvaluatorsChanged; } var mse = _interactive?.Evaluator as IMultipleScopeEvaluator; if (mse != null) { _scopeListVisible = mse.EnableMultipleScopes; mse.AvailableScopesChanged += AvailableScopesChanged; mse.MultipleScopeSupportChanged += MultipleScopeSupportChanged; } if (_next == null && _interactive != null) { ErrorHandler.ThrowOnFailure(vsTextView.AddCommandFilter(this, out _next)); } }
internal InteractiveWindowTestHost(Action <InteractiveWindow.State> stateChangedHandler = null) { try { ExportProvider = new CompositionContainer( s_lazyCatalog.Value, CompositionOptions.DisableSilentRejection | CompositionOptions.IsThreadSafe); Evaluator = new TestInteractiveEngine(); Window = ExportProvider.GetExport <IInteractiveWindowFactoryService>().Value.CreateWindow(Evaluator); ((InteractiveWindow)Window).StateChanged += stateChangedHandler; Window.InitializeAsync().Wait(); } catch (ReflectionTypeLoadException e) { Assert.False(true, e.Message + "LoaderExceptions: " + Environment.NewLine + string.Join(Environment.NewLine, e.LoaderExceptions.Select(l => l.Message))); } }
public override void PreviewKeyDown(KeyEventArgs args) { if (_interactiveWindow == null) { _interactiveWindow = _textView.TextBuffer.GetInteractiveWindow(); if (_interactiveWindow == null) { return; } } var tb = _interactiveWindow.CurrentLanguageBuffer; if (tb == null || !tb.ContentType.IsOfType(RContentTypeDefinition.ContentType)) { return; } var vk = KeyInterop.VirtualKeyFromKey(args.Key); // VK_0 to VK_Z, VK_OEM* if ((vk >= 0x30 && vk <= 0x5A) || (vk >= 0xBA && vk <= 0xC0) || (vk >= 0xDB && vk <= 0xDF)) { var spans = _textView.TextBuffer.GetReadOnlyExtents(new Text.Span(0, _textView.TextBuffer.CurrentSnapshot.Length)); var caret = _textView.Caret.Position.BufferPosition; var span = spans.FirstOrDefault(s => s.Contains(caret.Position)); if (span != default(Span)) { try { var viewPoint = _textView.BufferGraph.MapUpToBuffer(new SnapshotPoint(tb.CurrentSnapshot, tb.CurrentSnapshot.Length), PointTrackingMode.Positive, PositionAffinity.Predecessor, _textView.TextBuffer); if (viewPoint.HasValue) { _textView.Caret.MoveTo(viewPoint.Value); } } catch (ArgumentException) { } } base.PreviewKeyDown(args); } }
public void Show(IInteractiveWindow theWindow, DockingState state) { DockContent dockableWindow = theWindow as DockContent; if (dockableWindow != null) { DockState dockState = DockState.Document; if (state == DockingState.DockRight) { dockState = DockState.DockRight; } else if (state == DockingState.Float) { dockState = DockState.Float; } this.dockPanel.Invoke((MethodInvoker) delegate { dockableWindow.Show(this.dockPanel, dockState); }); } }
internal Commands(IInteractiveWindow window, string prefix, IEnumerable <IInteractiveWindowCommand> commands, IContentTypeRegistryService contentTypeRegistry = null, IStandardClassificationService classificationRegistry = null) { CommandPrefix = prefix; this.window = window; Dictionary <string, IInteractiveWindowCommand> commandsDict = new Dictionary <string, IInteractiveWindowCommand>(); foreach (var command in commands) { if (command.Name == null) { continue; } if (commandsDict.ContainsKey(command.Name)) { throw new InvalidOperationException(string.Format(InteractiveWindowResources.DuplicateCommand, command.Name)); } commandsDict[command.Name] = command; } this.commands = commandsDict; this.maxCommandNameLength = (this.commands.Count > 0) ? this.commands.Values.Select(command => command.Name.Length).Max() : 0; this.classificationRegistry = classificationRegistry; if (contentTypeRegistry != null) { this.commandContentType = contentTypeRegistry.GetContentType(InteractiveContentTypeNames.InteractiveCommandContentType); } if (window != null) { window.SubmissionBufferAdded += Window_SubmissionBufferAdded; window.Properties[typeof(IInteractiveWindowCommands)] = this; } }
public void SetLanguage(IInteractiveWindow window, Guid languageServiceGuid) { // REVIEW: What happens to the current input buffer here? // REVIEW: What happens when the window is already initialized? GetDispatcher(window).CheckAccess(); var commandFilter = GetCommandFilter(window); commandFilter.firstLanguageServiceCommandFilter = null; var provider = _oleCommandTargetProviders.OfContentType(window.Evaluator.ContentType, _contentTypeRegistry); if (provider != null) { var targetFilter = commandFilter.firstLanguageServiceCommandFilter ?? GetCommandFilter(window).EditorServicesCommandFilter; var target = provider.GetCommandTarget(window.TextView, targetFilter); if (target != null) { commandFilter.firstLanguageServiceCommandFilter = target; } } SetEditorOptions(window.TextView.Options, languageServiceGuid); }
public bool SupportsCodeFixes(Document document) { SourceText sourceText; if (document.TryGetText(out sourceText)) { ITextBuffer buffer = sourceText.Container.TryGetTextBuffer(); if (buffer != null) { IInteractiveEvaluator evaluator = (IInteractiveEvaluator)buffer.Properties[typeof(IInteractiveEvaluator)]; IInteractiveWindow window = evaluator?.CurrentWindow; if (window?.CurrentLanguageBuffer == buffer) { // These are only correct if we're on the UI thread. // Otherwise, they're guesses and they might change immediately even if they're correct. // If we return true and the buffer later becomes readonly, it appears that the // the code fix simply has no effect. return(!window.IsResetting && !window.IsRunning); } } } return(false); }
protected void ReportInvalidArguments(IInteractiveWindow window) { var commands = (IInteractiveWindowCommands)window.Properties[typeof(IInteractiveWindowCommands)]; commands.DisplayCommandUsage(this, window.ErrorOutputWriter, displayDetails: false); }
public abstract Task <ExecutionResult> Execute(IInteractiveWindow window, string arguments);
public void Dispose() { _evaluator?.Dispose(); _evaluator = null; _window = null; }
private InteractiveWindowWrapper(IInteractiveWindow interactiveWindow) { _interactiveWindow = interactiveWindow; }
private static async Task PasteReplCode( IInteractiveWindow window, string pasting, PythonLanguageVersion version ) { // there's some text in the buffer... var view = window.TextView; var caret = view.Caret; if (view.Selection.IsActive && !view.Selection.IsEmpty) { foreach (var span in view.Selection.SelectedSpans) { foreach (var normalizedSpan in view.BufferGraph.MapDownToBuffer(span, SpanTrackingMode.EdgeInclusive, window.CurrentLanguageBuffer)) { normalizedSpan.Snapshot.TextBuffer.Delete(normalizedSpan); } } } var curBuffer = window.CurrentLanguageBuffer; var inputPoint = view.BufferGraph.MapDownToBuffer( caret.Position.BufferPosition, PointTrackingMode.Positive, curBuffer, PositionAffinity.Successor ); // if we didn't find a location then see if we're in a prompt, and if so, then we want // to insert after the prompt. if (caret.Position.BufferPosition != window.TextView.TextBuffer.CurrentSnapshot.Length) { for (int i = caret.Position.BufferPosition + 1; inputPoint == null && i <= window.TextView.TextBuffer.CurrentSnapshot.Length; i++) { inputPoint = view.BufferGraph.MapDownToBuffer( new SnapshotPoint(window.TextView.TextBuffer.CurrentSnapshot, i), PointTrackingMode.Positive, curBuffer, PositionAffinity.Successor ); } } if (inputPoint == null) { // we didn't find a point to insert, insert at the beginning. inputPoint = new SnapshotPoint(curBuffer.CurrentSnapshot, 0); } // we want to insert the pasted code at the caret, but we also want to // respect the stepping. So first grab the code before and after the caret. string startText = curBuffer.CurrentSnapshot.GetText(0, inputPoint.Value); string endText = curBuffer.CurrentSnapshot.GetText( inputPoint.Value, curBuffer.CurrentSnapshot.Length - inputPoint.Value); var splitCode = JoinToCompleteStatements(SplitAndDedent(startText + pasting + endText), version).ToList(); curBuffer.Delete(new Span(0, curBuffer.CurrentSnapshot.Length)); bool supportMultiple = await window.GetSupportsMultipleStatements(); if (supportMultiple) { await window.SubmitAsync(new[] { string.Join(Environment.NewLine, splitCode) }); } else if (splitCode.Count == 1) { curBuffer.Insert(0, splitCode[0]); var viewPoint = view.BufferGraph.MapUpToBuffer( new SnapshotPoint(curBuffer.CurrentSnapshot, Math.Min(inputPoint.Value.Position + pasting.Length, curBuffer.CurrentSnapshot.Length)), PointTrackingMode.Positive, PositionAffinity.Successor, view.TextBuffer ); if (viewPoint != null) { view.Caret.MoveTo(viewPoint.Value); } } else if (splitCode.Count != 0) { var lastCode = splitCode[splitCode.Count - 1]; splitCode.RemoveAt(splitCode.Count - 1); while (splitCode.Any()) { var code = splitCode[0]; splitCode.RemoveAt(0); await window.SubmitAsync(new[] { code }); supportMultiple = await window.GetSupportsMultipleStatements(); if (supportMultiple) { // Might have changed while we were executing break; } } if (supportMultiple) { // Submit all remaning lines of code await window.SubmitAsync(new[] { string.Join(Environment.NewLine, splitCode) }); } else { window.CurrentLanguageBuffer.Insert(0, lastCode); } } else { window.CurrentLanguageBuffer.Insert(0, startText + pasting + endText); } }
internal static IVsInteractiveWindow GetVsInteractiveWindow(IInteractiveWindow window) { IVsInteractiveWindow wnd = null; return((window?.Properties.TryGetProperty(VsInteractiveWindowKey, out wnd) ?? false) ? wnd : null); }
public static Task <ExecutionResult> _Initialize(this IInteractiveEvaluator self, IInteractiveWindow window) { self.CurrentWindow = window; return(self.InitializeAsync()); }
public InteractiveWindowHistoryTests() { _testHost = new InteractiveWindowTestHost(); _window = _testHost.Window; _operations = _window.Operations; }
private void FlushOutput(IInteractiveWindow window) { // Give interactive window writer time to process message queue UIThreadHelper.Instance.DoEvents(400); window.FlushOutput(); }
public Task <ExecutionResult> Execute(IInteractiveWindow window, string arguments) { var finder = new FileFinder(arguments); var eval = window.GetPythonEvaluator(); if (eval != null) { finder.Search(eval.Configuration.WorkingDirectory); foreach (var p in eval.Configuration.SearchPaths) { finder.Search(p); } } finder.ThrowIfNotFound(); string commandPrefix = "$"; string lineBreak = window.TextView.Options.GetNewLineCharacter(); IEnumerable <string> lines = File.ReadLines(finder.Filename); IEnumerable <string> submissions; if (eval != null) { submissions = ReplEditFilter.JoinToCompleteStatements(lines, eval.LanguageVersion).Where(CommentPrefixPredicate); } else { // v1 behavior, will probably never be hit, but if someone was developing their own IReplEvaluator // and using this class it would be hit. var submissionList = new List <string>(); var currentSubmission = new List <string>(); foreach (var line in lines) { if (line.StartsWith(_commentPrefix)) { continue; } if (line.StartsWith(commandPrefix)) { AddSubmission(submissionList, currentSubmission, lineBreak); submissionList.Add(line); currentSubmission.Clear(); } else { currentSubmission.Add(line); } } AddSubmission(submissionList, currentSubmission, lineBreak); submissions = submissionList; } window.SubmitAsync(submissions); return(ExecutionResult.Succeeded); }
internal static int GetVsInteractiveWindowId(IInteractiveWindow window) { int id = -1; return((window?.Properties.TryGetProperty(VsInteractiveWindowId, out id) ?? false) ? id : -1); }
public VsInteractiveWindowCommandFilter GetCommandFilter(IInteractiveWindow window) { return((VsInteractiveWindowCommandFilter)window.Properties[typeof(VsInteractiveWindowCommandFilter)]); }
protected abstract Task <IEnumerable <string> > GetNamespacesToImportAsync(IEnumerable <string> namespacesToImport, IInteractiveWindow interactiveWindow);
protected override Task <IEnumerable <string> > GetNamespacesToImportAsync(IEnumerable <string> namespacesToImport, IInteractiveWindow interactiveWindow) { return(Task.FromResult((IEnumerable <string>)NamespacesToImport)); }
public VsInteractiveWindowCommandFilter(IVsEditorAdaptersFactoryService adapterFactory, IInteractiveWindow window, IVsTextView textViewAdapter, IVsTextBuffer bufferAdapter) { _window = window; this.textViewAdapter = textViewAdapter; // make us a code window so we'll have the same colors as a normal code window. IVsTextEditorPropertyContainer propContainer; ErrorHandler.ThrowOnFailure(((IVsTextEditorPropertyCategoryContainer)textViewAdapter).GetPropertyCategory(Microsoft.VisualStudio.Editor.DefGuidList.guidEditPropCategoryViewMasterSettings, out propContainer)); propContainer.SetProperty(VSEDITPROPID.VSEDITPROPID_ViewComposite_AllCodeWindowDefaults, true); propContainer.SetProperty(VSEDITPROPID.VSEDITPROPID_ViewGlobalOpt_AutoScrollCaretOnTextEntry, true); // editor services are initialized in textViewAdapter.Initialize - hook underneath them: _preEditorCommandFilter = new CommandFilter(this, CommandFilterLayer.PreEditor); ErrorHandler.ThrowOnFailure(textViewAdapter.AddCommandFilter(_preEditorCommandFilter, out _editorCommandFilter)); textViewAdapter.Initialize( (IVsTextLines)bufferAdapter, IntPtr.Zero, (uint)TextViewInitFlags.VIF_HSCROLL | (uint)TextViewInitFlags.VIF_VSCROLL | (uint)TextViewInitFlags3.VIF_NO_HWND_SUPPORT, new[] { new INITVIEW { fSelectionMargin = 0, fWidgetMargin = 0, fVirtualSpace = 0, fDragDropMove = 1 } }); // disable change tracking because everything will be changed var textViewHost = adapterFactory.GetWpfTextViewHost(textViewAdapter); _preLanguageCommandFilter = new CommandFilter(this, CommandFilterLayer.PreLanguage); ErrorHandler.ThrowOnFailure(textViewAdapter.AddCommandFilter(_preLanguageCommandFilter, out _editorServicesCommandFilter)); _textViewHost = textViewHost; }
internal InteractiveWindowWriter(IInteractiveWindow window, SortedSpans spans) { Debug.Assert(window != null); this.window = window; this.spans = spans; }
public override Task <ExecutionResult> Execute(IInteractiveWindow window, string arguments) { window.Operations.ClearView(); return(ExecutionResult.Succeeded); }
private Dispatcher GetDispatcher(IInteractiveWindow window) { return(((FrameworkElement)window.TextView).Dispatcher); }
public IInteractiveWindowCommands CreateInteractiveCommands(IInteractiveWindow window, string prefix, IEnumerable <IInteractiveWindowCommand> commands) { return(new Commands(window, prefix, commands.ToArray(), _contentTypeRegistry, _standardClassification)); }
protected override async Task <IEnumerable <string> > GetNamespacesToImportAsync(IEnumerable <string> namespacesToImport, IInteractiveWindow interactiveWindow) { var document = interactiveWindow.CurrentLanguageBuffer.CurrentSnapshot.GetOpenDocumentInCurrentContextWithChanges(); var compilation = await document.Project.GetCompilationAsync().ConfigureAwait(true); return(namespacesToImport.Where(ns => compilation.GlobalNamespace.GetQualifiedNamespace(ns) != null)); }