public static WaitIndicatorResult Wait( this IWaitIndicator waitIndicator, string title, string message, bool allowCancel, Action <IWaitContext> action) { return(waitIndicator.Wait(title, message, allowCancel, showProgress: false, action: action)); }
public static WaitIndicatorResult Wait( this IWaitIndicator waitIndicator, string titleAndMessage, bool allowCancel, Action <IWaitContext> action ) => waitIndicator.Wait(titleAndMessage, titleAndMessage, allowCancel, action);
public void ExecuteCommand(AutomaticLineEnderCommandArgs args, Action nextHandler) { // get editor operation var operations = _editorOperationsFactoryService.GetEditorOperations(args.TextView); if (operations == null) { nextHandler(); return; } var document = args.SubjectBuffer.CurrentSnapshot.GetOpenDocumentInCurrentContextWithChanges(); if (document == null) { NextAction(operations, nextHandler); return; } // feature off if (!document.Project.Solution.Workspace.Options.GetOption(InternalFeatureOnOffOptions.AutomaticLineEnder)) { NextAction(operations, nextHandler); return; } _waitIndicator.Wait( title: EditorFeaturesResources.AutomaticLineEnder, message: EditorFeaturesResources.AutomaticallyCompleting, allowCancel: false, action: w => { // caret is not on the subject buffer. nothing we can do var position = args.TextView.GetCaretPoint(args.SubjectBuffer); if (!position.HasValue) { NextAction(operations, nextHandler); return; } var subjectLineWhereCaretIsOn = position.Value.GetContainingLine(); var insertionPoint = GetInsertionPoint(document, subjectLineWhereCaretIsOn, w.CancellationToken); if (!insertionPoint.HasValue) { NextAction(operations, nextHandler); return; } // special cases where we treat this command simply as Return. if (TreatAsReturn(document, position.Value.Position, w.CancellationToken)) { // leave it to the VS editor to handle this command. // VS editor's default implementation of SmartBreakLine is simply BreakLine, which inserts // a new line and positions the caret with smart indent. nextHandler(); return; } using (var transaction = args.TextView.CreateEditTransaction(EditorFeaturesResources.AutomaticLineEnder, _undoRegistry, _editorOperationsFactoryService)) { // try to move the caret to the end of the line on which the caret is args.TextView.TryMoveCaretToAndEnsureVisible(subjectLineWhereCaretIsOn.End); // okay, now insert ending if we need to var newDocument = InsertEndingIfRequired(document, insertionPoint.Value, position.Value, w.CancellationToken); // format the document and apply the changes to the workspace FormatAndApply(newDocument, insertionPoint.Value, w.CancellationToken); // now, insert new line NextAction(operations, nextHandler); transaction.Complete(); } }); }
public void ExecuteCommand(SyncClassViewCommandArgs args, Action nextHandler) { this.AssertIsForeground(); var caretPosition = args.TextView.GetCaretPoint(args.SubjectBuffer) ?? -1; if (caretPosition < 0) { nextHandler(); return; } var snapshot = args.SubjectBuffer.CurrentSnapshot; _waitIndicator.Wait( title: string.Format(ServicesVSResources.Synchronize_0, ClassView), message: string.Format(ServicesVSResources.Synchronizing_with_0, ClassView), allowCancel: true, action: context => { var document = snapshot.GetOpenDocumentInCurrentContextWithChanges(); if (document == null) { return; } var syntaxFactsService = document.Project.LanguageServices.GetService <ISyntaxFactsService>(); if (syntaxFactsService == null) { return; } var libraryService = document.Project.LanguageServices.GetService <ILibraryService>(); if (libraryService == null) { return; } var semanticModel = document .GetSemanticModelAsync(context.CancellationToken) .WaitAndGetResult(context.CancellationToken); var root = semanticModel.SyntaxTree .GetRootAsync(context.CancellationToken) .WaitAndGetResult(context.CancellationToken); var memberDeclaration = syntaxFactsService.GetContainingMemberDeclaration(root, caretPosition); var symbol = memberDeclaration != null ? semanticModel.GetDeclaredSymbol(memberDeclaration, context.CancellationToken) : null; while (symbol != null && !IsValidSymbolToSynchronize(symbol)) { symbol = symbol.ContainingSymbol; } IVsNavInfo navInfo = null; if (symbol != null) { navInfo = libraryService.NavInfoFactory.CreateForSymbol(symbol, document.Project, semanticModel.Compilation, useExpandedHierarchy: true); } if (navInfo == null) { navInfo = libraryService.NavInfoFactory.CreateForProject(document.Project); } if (navInfo == null) { return; } var navigationTool = _serviceProvider.GetService <SVsClassView, IVsNavigationTool>(); navigationTool.NavigateToNavInfo(navInfo); }); }
public int GetNameOfLocation( IVsTextBuffer pBuffer, int iLine, int iCol, out string?pbstrName, out int piLineOffset ) { using ( Logger.LogBlock( FunctionId.Debugging_VsLanguageDebugInfo_GetNameOfLocation, CancellationToken.None ) ) { string?name = null; var lineOffset = 0; if (_languageDebugInfo != null) { _waitIndicator.Wait( title: ServicesVSResources.Debugger, message: ServicesVSResources.Determining_breakpoint_location, allowCancel: true, action: waitContext => { var cancellationToken = waitContext.CancellationToken; var textBuffer = _languageService.EditorAdaptersFactoryService.GetDataBuffer( pBuffer ); if (textBuffer != null) { var nullablePoint = textBuffer.CurrentSnapshot.TryGetPoint( iLine, iCol ); if (nullablePoint.HasValue) { var point = nullablePoint.Value; var document = point.Snapshot.GetOpenDocumentInCurrentContextWithChanges(); if (document != null) { // NOTE(cyrusn): We have to wait here because the debuggers' // GetNameOfLocation is a blocking call. In the future, it // would be nice if they could make it async. var debugLocationInfo = _languageDebugInfo .GetLocationInfoAsync( document, point, cancellationToken ) .WaitAndGetResult(cancellationToken); if (!debugLocationInfo.IsDefault) { name = debugLocationInfo.Name; lineOffset = debugLocationInfo.LineOffset; } } } } } ); if (name != null) { pbstrName = name; piLineOffset = lineOffset; return(VSConstants.S_OK); } } // Note(DustinCa): Docs say that GetNameOfLocation should return S_FALSE if a name could not be found. // Also, that's what the old native code does, so we should do it here. pbstrName = null; piLineOffset = 0; return(VSConstants.S_FALSE); } }
public void AugmentPeekSession(IPeekSession session, IList <IPeekableItem> peekableItems) { if (!string.Equals(session.RelationshipName, PredefinedPeekRelationships.Definitions.Name, StringComparison.OrdinalIgnoreCase)) { return; } var triggerPoint = session.GetTriggerPoint(_textBuffer.CurrentSnapshot); if (!triggerPoint.HasValue) { return; } var document = triggerPoint.Value.Snapshot.GetOpenDocumentInCurrentContextWithChanges(); if (document == null) { return; } _waitIndicator.Wait(EditorFeaturesResources.Peek, EditorFeaturesResources.Loading_Peek_information, allowCancel: true, action: context => { var cancellationToken = context.CancellationToken; IEnumerable <IPeekableItem> results; if (!document.SupportsSemanticModel) { // For documents without semantic models, just try to use the goto-def service // as a reasonable place to peek at. var goToDefinitionService = document.GetLanguageService <IGoToDefinitionService>(); if (goToDefinitionService == null) { return; } var navigableItems = goToDefinitionService.FindDefinitionsAsync(document, triggerPoint.Value.Position, cancellationToken) .WaitAndGetResult(cancellationToken); results = GetPeekableItemsForNavigableItems(navigableItems, document.Project, _peekResultFactory, cancellationToken); } else { var semanticModel = document.GetSemanticModelAsync(cancellationToken).WaitAndGetResult(cancellationToken); var symbol = SymbolFinder.GetSemanticInfoAtPositionAsync( semanticModel, triggerPoint.Value.Position, document.Project.Solution.Workspace, cancellationToken).WaitAndGetResult(cancellationToken) .GetAnySymbol(includeType: true); if (symbol == null) { return; } symbol = symbol.GetOriginalUnreducedDefinition(); // Get the symbol back from the originating workspace var symbolMappingService = document.Project.Solution.Workspace.Services.GetRequiredService <ISymbolMappingService>(); var mappingResult = symbolMappingService.MapSymbolAsync(document, symbol, cancellationToken) .WaitAndGetResult(cancellationToken); mappingResult ??= new SymbolMappingResult(document.Project, symbol); results = _peekableItemFactory.GetPeekableItemsAsync(mappingResult.Symbol, mappingResult.Project, _peekResultFactory, cancellationToken) .WaitAndGetResult(cancellationToken); } peekableItems.AddRange(results); }); }