public override ITreeRange Format(
            ITreeNode firstElement, ITreeNode lastElement,
            CodeFormatProfile profile, IProgressIndicator pi,
            IContextBoundSettingsStore overrideSettingsStore = null)
        {
            ITreeNode firstNode;
            ITreeNode lastNode;

            GetFirstAndLastNode(firstElement, lastElement, out firstNode, out lastNode);

            using (pi.SafeTotal(4))
            {
                var context = new PsiCodeFormattingContext(this, firstNode, lastNode);
                if (profile != CodeFormatProfile.INDENT)
                {
                    using (IProgressIndicator subPi = pi.CreateSubProgress(2))
                    {
                        using (subPi.SafeTotal(2))
                        {
                            PsiFormattingStage.DoFormat(context, subPi.CreateSubProgress(1));
                            PsiIndentingStage.DoIndent(context, subPi.CreateSubProgress(1), false);
                        }
                    }
                }
                else
                {
                    using (IProgressIndicator subPi = pi.CreateSubProgress(4))
                    {
                        PsiIndentingStage.DoIndent(context, subPi, true);
                    }
                }
            }
            return(new TreeRange(firstElement, lastElement));
        }
Beispiel #2
0
        public static void DoIndent(CodeFormattingContext context, IProgressIndicator progress, bool inTypingAssist)
        {
            var indentCache = new PsiIndentCache(context.CodeFormatter,
                                                 AlignmentTabFillStyle.USE_SPACES, new GlobalFormatSettings(true, 2));

            _indentVisitor = CreateIndentVisitor(indentCache, inTypingAssist);
            var stage = new PsiIndentingStage(inTypingAssist);
            //List<FormattingRange> nodePairs = context.SequentialEnumNodes().Where(p => context.CanModifyInsideNodeRange(p.First, p.Last)).ToList();
            List <FormattingRange> nodePairs = context.GetNodePairs().Where(p => context.CanModifyInsideNodeRange(p.First, p.Last)).ToList();
            //nodePairs.Add(new FormattingRange(null, context.FirstNode));
            IEnumerable <FormatResult <string> > indents = nodePairs.
                                                           Select(range => new FormatResult <string>(range, stage.CalcIndent(new FormattingStageContext(range)))).
                                                           Where(res => res.ResultValue != null);

            FormatterImplHelper.ForeachResult(
                indents,
                progress,
                res => res.Range.Last.MakeIndent(res.ResultValue));
        }
    public static void DoIndent(PsiCodeFormattingSettings formattingSettings, CodeFormattingContext context, IProgressIndicator progress, bool inTypingAssist)
    {
      /*PsiIndentCache indentCache = new PsiIndentCache(
        context.CodeFormatter,
        null,
        formattingSettings.CommonSettings.ALIGNMENT_TAB_FILL_STYLE,
        formattingSettings.GlobalSettings); */
      PsiIndentCache indentCache = new PsiIndentCache();
      myIndentVisitor = CreateIndentVisitor(indentCache, inTypingAssist);
      var stage = new PsiIndentingStage(formattingSettings, inTypingAssist);
      List<FormattingRange> nodePairs = context.SequentialEnumNodes().Where(p => context.CanModifyInsideNodeRange(p.First, p.Last)).ToList();
      IEnumerable<FormatResult<string>> indents = nodePairs.
        Select(range => new FormatResult<string>(range, stage.CalcIndent(new FormattingStageContext(range)))).
        Where(res => res.ResultValue != null);

      FormatterImplHelper.ForeachResult(
        indents,
        progress,
        res => res.Range.Last.MakeIndent(res.ResultValue));
    }
Beispiel #4
0
        public static void DoIndent(PsiCodeFormattingSettings formattingSettings, CodeFormattingContext context, IProgressIndicator progress, bool inTypingAssist)
        {
            /*PsiIndentCache indentCache = new PsiIndentCache(
             * context.CodeFormatter,
             * null,
             * formattingSettings.CommonSettings.ALIGNMENT_TAB_FILL_STYLE,
             * formattingSettings.GlobalSettings); */
            PsiIndentCache indentCache = new PsiIndentCache();

            myIndentVisitor = CreateIndentVisitor(indentCache, inTypingAssist);
            var stage = new PsiIndentingStage(formattingSettings, inTypingAssist);
            List <FormattingRange> nodePairs             = context.SequentialEnumNodes().Where(p => context.CanModifyInsideNodeRange(p.First, p.Last)).ToList();
            IEnumerable <FormatResult <string> > indents = nodePairs.
                                                           Select(range => new FormatResult <string>(range, stage.CalcIndent(new FormattingStageContext(range)))).
                                                           Where(res => res.ResultValue != null);

            FormatterImplHelper.ForeachResult(
                indents,
                progress,
                res => res.Range.Last.MakeIndent(res.ResultValue));
        }
Beispiel #5
0
        public override ITreeRange Format(ITreeNode firstElement, ITreeNode lastElement, CodeFormatProfile profile, [CanBeNull] IProgressIndicator pi, IContextBoundSettingsStore overrideSettingsStore = null)
        {
            var       psiProfile = new PsiFormatProfile(profile);
            ITreeNode firstNode  = firstElement;
            ITreeNode lastNode   = lastElement;

            if (firstElement != lastElement)
            {
                if (firstElement == null)
                {
                    firstNode = lastElement;
                }
                ITreeNode commonParent = firstNode.FindCommonParent(lastNode);
                ITreeNode firstChild   = firstNode;
                ITreeNode lastChild    = lastElement;
                while (firstChild.Parent != commonParent)
                {
                    firstChild = firstChild.Parent;
                }
                while (lastChild.Parent != commonParent)
                {
                    lastChild = lastChild.Parent;
                }

                bool hasPrevSibling = false;
                while (firstNode.NextSibling == null)
                {
                    if (firstNode.PrevSibling != null)
                    {
                        hasPrevSibling = true;
                    }
                    firstNode = firstNode.Parent;
                    if (firstNode == firstChild)
                    {
                        break;
                    }
                }
                if (hasPrevSibling)
                {
                    while ((firstNode == firstChild) || (firstChild.IsWhitespaceToken()))
                    {
                        firstChild = firstChild.NextSibling;
                    }
                }
                firstNode = firstChild;
                while (firstNode.FirstChild != null)
                {
                    firstNode = firstNode.FirstChild;
                }
            }
            else
            {
                if (firstElement.FirstChild != null)
                {
                    firstNode = firstElement.FirstChild;
                    lastNode  = firstElement.LastChild;
                }
            }
            ISolution            solution = firstNode.GetSolution();
            var                  contextBoundSettingsStore = GetProperContextBoundSettingsStore(overrideSettingsStore, firstNode);
            GlobalFormatSettings globalSettings            = GlobalFormatSettingsHelper.GetService(solution).GetSettingsForLanguage(myLanguage);
            //var formatterSettings = new PsiCodeFormattingSettings(globalSettings, contextBoundSettingsStore.GetKey<CommonFormatterSettingsKey>(mySettingsOptimization));
            var formatterSettings = new PsiCodeFormattingSettings(globalSettings);

            using (pi.SafeTotal(4))
            {
                var context = new PsiCodeFormattingContext(this, firstNode, lastNode, NullProgressIndicator.Instance);
                if (psiProfile.Profile != CodeFormatProfile.INDENT)
                {
                    using (pi.CreateSubProgress(1))
                    {
                        //FormatterImplHelper.DecoratingIterateNodes(context, context.FirstNode, context.LastNode, new PsiDecorationStage(formatterSettings, psiProfile, subPi));
                    }

                    using (IProgressIndicator subPi = pi.CreateSubProgress(1))
                    {
                        using (subPi.SafeTotal(2))
                        {
                            var data = new FormattingStageData(formatterSettings, context, psiProfile, myExtensions.ToList());
                            PsiFormattingStage.DoFormat(data, subPi.CreateSubProgress(1));
                            PsiIndentingStage.DoIndent(formatterSettings, context, subPi.CreateSubProgress(1), false);
                        }
                    }
                }
                else
                {
                    using (IProgressIndicator subPi = pi.CreateSubProgress(4))
                    {
                        PsiIndentingStage.DoIndent(formatterSettings, context, subPi, true);
                    }
                }
            }
            return(new TreeRange(firstElement, lastElement));
        }