C# ITextControl类代码示例

            protected override void AcceptExpression(
        ITextControl textControl, ISolution solution, TextRange resultRange, ICSharpExpression expression)
            {
                // set selection for introduce field
                textControl.Selection.SetRanges(new[] {TextControlPosRange.FromDocRange(textControl, resultRange)});

                const string name = "IntroFieldAction";
                var rules = DataRules
                  .AddRule(name, ProjectModel.DataContext.DataConstants.SOLUTION, solution)
                  .AddRule(name, DataConstants.DOCUMENT, textControl.Document)
                  .AddRule(name, TextControl.DataContext.DataConstants.TEXT_CONTROL, textControl)
                  .AddRule(name, Psi.Services.DataConstants.SELECTED_EXPRESSION, expression);

                Lifetimes.Using(lifetime =>
                  WorkflowExecuter.ExecuteBatch(
                Shell.Instance.GetComponent<DataContexts>().CreateWithDataRules(lifetime, rules),
                new IntroFieldWorkflow(solution, null)));

                // todo: rename hotspots

                var ranges = textControl.Selection.Ranges.Value;
                if (ranges.Count == 1) // reset selection
                {
                  var endPos = ranges[0].End;
                  textControl.Selection.SetRanges(new[] {new TextControlPosRange(endPos, endPos)});
                }
            }

        /// <inheritdoc />
        public override void ExecuteTransactionInner(ISolution solution, ITextControl textControl)
        {
            IDeclaration declaration = Utils.GetTypeClosestToTextControl<IDeclaration>(solution, textControl);

            // Fixes SA1604, 1605
            new DocumentationRules().InsertMissingSummaryElement(declaration);
        }

        /// <summary>
        /// The execute transaction inner.
        /// </summary>
        /// <param name="solution">
        /// The solution.
        /// </param>
        /// <param name="textControl">
        /// The text control.
        /// </param>
        public override void ExecuteTransactionInner(ISolution solution, ITextControl textControl)
        {
            IElement element = Utils.GetElementAtCaret(solution, textControl);

            if (element == null)
            {
                return;
            }

            IUsingListNode usingList = element.GetContainingElement(typeof(IUsingListNode), false) as IUsingListNode;

            if (usingList == null)
            {
                return;
            }

            ICSharpFile file = Utils.GetCSharpFile(solution, textControl);

            // This violation will only run if there are some using statements and definately at least 1 namespace
            // so [0] index will always be OK.
            ICSharpNamespaceDeclaration firstNamespace = file.NamespaceDeclarations[0];

            foreach (IUsingDirectiveNode usingDirectiveNode in usingList.Imports)
            {
                firstNamespace.AddImportBefore(usingDirectiveNode, null);

                file.RemoveImport(usingDirectiveNode);
            }
        }

        /// <summary>
        /// The execute transaction inner.
        /// </summary>
        /// <param name="solution">
        /// The solution.
        /// </param>
        /// <param name="textControl">
        /// The text control.
        /// </param>
        public override void ExecuteTransactionInner(ISolution solution, ITextControl textControl)
        {
            ICSharpFile file = Utils.GetCSharpFile(solution, textControl);

            IRangeMarker marker = this.DocumentRange.CreateRangeMarker();
            file.ArrangeThisQualifier(marker);
        }

 /// <summary>
 /// The execute transaction inner.
 /// </summary>
 /// <param name="solution">
 /// The solution.
 /// </param>
 /// <param name="textControl">
 /// The text control.
 /// </param>
 public override void ExecuteTransactionInner(ISolution solution, ITextControl textControl)
 {
     string documentation = this.DocumentRange.GetText();
     Regex regEx = new Regex("(((///[ ^ ] *)))|((///))");
     documentation = regEx.Replace(documentation, "/// ");
     textControl.Document.ReplaceText(this.DocumentRange.TextRange, documentation);
 }

        public void Execute(ISolution solution, ITextControl textControl)
        {
            // TODO extract add attribute to another class
            // method name  IDeclaredParameter AddDeclaredParameter()

            if (missedParameterError.Descriptor.IsAttribute)
            {
                IDocument document = textControl.Document;
                using (ModificationCookie cookie = document.EnsureWritable())
                {
                    int navigationOffset = -1;

                    try
                    {
                        CommandProcessor.Instance.BeginCommand("TextControl:AddAttribute");
                        string toInsert = " " + this.missedParameterError.Descriptor.Name + "=\"\"";
                        document.InsertText(this.headerNameRange.TextRange.EndOffset, toInsert);
                        navigationOffset = (this.headerNameRange.TextRange.EndOffset + toInsert.Length) - 1;
                    }
                    finally
                    {
                        CommandProcessor.Instance.EndCommand();
                    }
                    if (navigationOffset != -1)
                    {
                        textControl.CaretModel.MoveTo(navigationOffset, TextControlScrollType.MAKE_VISIBLE);
                        // todo run Completion Action
                    }
                }
            }
            else
            {
                Assert.Fail();
            }
        }

        /// <summary>
        /// The execute transaction inner.
        /// </summary>
        /// <param name="solution">
        /// The solution.
        /// </param>
        /// <param name="textControl">
        /// The text control.
        /// </param>
        public override void ExecuteTransactionInner(ISolution solution, ITextControl textControl)
        {
            ITreeNode element = Utils.GetElementAtCaret(solution, textControl);
            IBlock containingBlock = element.GetContainingNode<IBlock>(true);

            if (containingBlock != null)
            {
                //// CSharpFormatterHelper.FormatterInstance.Format(containingBlock);
                ICSharpCodeFormatter codeFormatter = (ICSharpCodeFormatter)CSharpLanguage.Instance.LanguageService().CodeFormatter;
                codeFormatter.Format(containingBlock);

                new LayoutRules().CurlyBracketsForMultiLineStatementsMustNotShareLine(containingBlock);
            }
            else
            {
                IFieldDeclaration fieldDeclarationNode = element.GetContainingNode<IFieldDeclaration>(true);
                if (fieldDeclarationNode != null)
                {
                    //// CSharpFormatterHelper.FormatterInstance.Format(fieldDeclarationNode);
                    ICSharpCodeFormatter codeFormatter = (ICSharpCodeFormatter)CSharpLanguage.Instance.LanguageService().CodeFormatter;
                    codeFormatter.Format(fieldDeclarationNode);

                    new LayoutRules().CurlyBracketsForMultiLineStatementsMustNotShareLine(fieldDeclarationNode);
                }
            }
        }

        /// <summary>
        /// The execute inner.
        /// </summary>
        /// <param name="solution">
        /// The solution.
        /// </param>
        /// <param name="textControl">
        /// The text control.
        /// </param>
        public override void ExecuteTransactionInner(ISolution solution, ITextControl textControl)
        {
            ICSharpModifiersOwnerDeclaration declaration = Utils.GetTypeClosestToTextControl<ICSharpModifiersOwnerDeclaration>(solution, textControl);

            if (declaration != null)
            {
                string rulesNamespace = this.Rule.Namespace;

                string ruleText = string.Format("{0}:{1}", this.Rule.CheckId, this.Rule.Name);

                IContextBoundSettingsStore settingsStore = PsiSourceFileExtensions.GetSettingsStore(null, solution);

                string justificationText = settingsStore.GetValue((StyleCopOptionsSettingsKey key) => key.SuppressStyleCopAttributeJustificationText);

                IAttributesOwnerDeclaration attributesOwnerDeclaration = declaration as IAttributesOwnerDeclaration;

                CSharpElementFactory factory = CSharpElementFactory.GetInstance(declaration.GetPsiModule());

                ITypeElement typeElement = Utils.GetTypeElement(declaration, "System.Diagnostics.CodeAnalysis.SuppressMessageAttribute");

                IAttribute attribute = factory.CreateAttribute(typeElement);

                ICSharpArgument newArg1 = attribute.AddArgumentAfter(Utils.CreateConstructorArgumentValueExpression(declaration.GetPsiModule(), rulesNamespace), null);

                ICSharpArgument newArg2 = attribute.AddArgumentAfter(Utils.CreateConstructorArgumentValueExpression(declaration.GetPsiModule(), ruleText), newArg1);

                attribute.AddArgumentAfter(Utils.CreateArgumentValueExpression(declaration.GetPsiModule(), "Justification = \"" + justificationText + "\""), newArg2);

                attributesOwnerDeclaration.AddAttributeAfter(attribute, null);
            }
        }

 /// <summary>
 /// Renders the footer tag and appropriate html to the given text control
 /// </summary>
 /// <param name="page">Page to get the content from that is supposed to be rendered</param>
 /// <param name="footerControl">The control to render the html to</param>
 public static void RenderFooterHtmlToControl(Page page, ITextControl footerControl)
 {
     if (!string.IsNullOrEmpty(page.FooterHtml))
     {
         footerControl.Text = "<footer>" + HttpUtility.HtmlEncode(page.FooterHtml) + "</footer>";
     }
 }

 /// <summary>
 /// Renders the header tag and appropriate html to the given text control
 /// </summary>
 /// <param name="page">Page to get the content from that is suppose to be rendered</param>
 /// <param name="headerControl">The control to render the html to</param>
 public static void RenderHtmlHeaderToControl(Page page, ITextControl headerControl)
 {
     if (!string.IsNullOrEmpty(page.HeaderHtml))
     {
         headerControl.Text = "<header>" + HttpUtility.HtmlEncode(page.HeaderHtml) + "</header>";
     }
 }

 /// <summary>
 /// Renders the CanonicalUrl to the passed in text control
 /// </summary>
 /// <param name="page">The page object to get the canonicalUrl from</param>
 /// <param name="canonicalLinkControl">The control to render the html to</param>
 public static void RenderCanonicalUrlToControl(Page page, ITextControl canonicalLinkControl)
 {
     if (!string.IsNullOrEmpty(page.CanonicalUrl))
     {
         canonicalLinkControl.Text = "<link rel=\"canonical\" href=\"" + HttpUtility.HtmlEncode(page.CanonicalUrl) + "\"/>";
     }
 }

    public void Execute(ISolution solution, ITextControl textControl)
    {
      if (!_literalExpression.IsValid())
        return;

      IFile containingFile = _literalExpression.GetContainingFile();

      CSharpElementFactory elementFactory = CSharpElementFactory.GetInstance(_literalExpression.GetPsiModule());

      IExpression newExpression = null;
      _literalExpression.GetPsiServices().PsiManager.DoTransaction(
        () =>
          {
            using (solution.GetComponent<IShellLocks>().UsingWriteLock())
              newExpression = ModificationUtil.ReplaceChild(
                _literalExpression, elementFactory.CreateExpression("System.Int16.MaxValue"));
          }, GetType().Name);

      if (newExpression != null)
      {
        IRangeMarker marker = newExpression.GetDocumentRange().CreateRangeMarker(solution.GetComponent<DocumentManager>());
        containingFile.OptimizeImportsAndRefs(
          marker, false, true, NullProgressIndicator.Instance);
      }
    }

 protected static void SetCaretPosition(ITextControl textControl, PsiIntentionResult result)
 {
   if (result.PrefferedSelection != DocumentRange.InvalidRange)
   {
     textControl.Selection.SetRange(result.PrefferedSelection.TextRange);
   }
 }

        /// <summary>
        /// The execute transaction inner.
        /// </summary>
        /// <param name="solution">
        /// The solution.
        /// </param>
        /// <param name="textControl">
        /// The text control.
        /// </param>
        public override void ExecuteTransactionInner(ISolution solution, ITextControl textControl)
        {
            ICSharpFile file = Utils.GetCSharpFile(solution, textControl);

            // Fixes SA1639
            DocumentationRules.InsertFileHeaderSummary(file);
        }

        public void Execute(ISolution solution, ITextControl textControl)
        {
            if (!MethodDeclaration.IsValid())
            {
                return;
            }

            var containingFile = MethodDeclaration.GetContainingFile();
            var psiModule = MethodDeclaration.GetPsiModule();
            var elementFactory = CSharpElementFactory.GetInstance(psiModule);
            var declared = MethodDeclaration.DeclaredElement;
            if (declared != null)
            {
                var newName = declared.ShortName + "Async";

                var refactoringService = solution.GetComponent<RenameRefactoringService>();
                var suggests = new List<string> {newName};
                SearchDomainFactory searchDomainFactory = solution.GetComponent<SearchDomainFactory>();
                var workflow = (IRefactoringWorkflow)new MethodRenameWorkflow(suggests, solution.GetComponent<IShellLocks>(), searchDomainFactory, refactoringService, solution, "TypoRename");

                var renames = RenameRefactoringService.Instance.CreateAtomicRenames(declared, newName, true).ToList();
               // var workflow = RenameFromContexts.InitFromNameChanges(solution, renames);
                //                workflow.CreateRefactoring();
                Lifetimes.Using(lifetime => RefactoringActionUtil.ExecuteRefactoring(solution.GetComponent<IActionManager>().DataContexts.CreateOnSelection(lifetime, DataRules.AddRule("DoTypoRenameWorkflow", DataConstants.SOLUTION, solution)), workflow));
            }
        }