C# Framework.Scope类代码示例

        public List<SplitPoint> GetSplitPoints(Scope root, int newScopeStartIndex, int newScopeLength)
        {
            List<SplitPoint> splitPoints = new List<SplitPoint>();
            if(root.IsFlat)
            {
                return splitPoints;
            }
            int requestedEndPos = newScopeStartIndex + newScopeLength - 1;
            Scope innerLeft = root.FindInnerScope(newScopeStartIndex, 1);
            Scope innerRight = root.FindInnerScope(requestedEndPos, 1);

            bool isSpillingLeft = (innerLeft.StartPosInRootScope < newScopeStartIndex);
            bool isSpillingRight = (innerRight.EndPosInRootScope > requestedEndPos);

            if (isSpillingLeft)
            {
                int splitLength = (innerLeft.EndPosInRootScope-newScopeStartIndex)+1;
                splitPoints.Add(new  SplitPoint(newScopeStartIndex, splitLength));
            }
            if (isSpillingRight)
            {
                int splitLength = (requestedEndPos-innerRight.StartPosInRootScope)+1;
                splitPoints.Add(new SplitPoint(innerRight.StartPosInRootScope, splitLength));
            //                splitPoints.Add(new SplitPoint(requestedEndPos, splitLength));
            }
            return splitPoints;
        }

        private void addScopeLeaf(TreeNode parentTreeNode, string label, Scope scope)
        {
            if (scope == null) return;

            TreeNode newNode = parentTreeNode.Nodes.Add(key(scope),"["+ scope.StartPosInRootScope + "-" + scope.Length +"]" + scope.Text.Replace("\n", "\\n"));
            newNode.Tag = scope;
            AddScope(scope, newNode);
        }

 protected internal override void DrawCustomForSingleSurroundingRect(Rectangle rect, Scope scopeToDraw)
 {
     startLineIndex = txt.GetLineFromCharIndex(scopeToDraw.StartPosInRootScope);
     endLineIndex = txt.GetLineFromCharIndex(scopeToDraw.EndPosInRootScope);
     string text = string.Format("Start:{0},End:{1}",startLineIndex,endLineIndex);
     txt.FindForm().Text = text;
     //            Font font = new Font(txt.Font.FontFamily,txt.Font.Size*2);
     //            graphics.DrawString(text,font,Brushes.Red,txt.Location);
 }

 private Scope GetFirstNamedParentScopeFor(Scope child)
 {
     Scope parent = child.ParentScope;
     while (parent!=null && parent.Name==string.Empty)
     {
         parent = parent.ParentScope;
     }
     return parent;
 }

 public void Highlight(Scope s)
 {
     HideSelection = false;
     TreeNode[] found = Nodes.Find(key(s),true);
     if(found.Length==0)
         return;
     TreeNode foundFirst = found[0];
     this.SelectedNode = foundFirst;
 }

        private static void doRunAutoScope(RegexAdvisor advisor, Scope root)
        {
            ThreadStart start = delegate
                                        {
                                            advisor.AutoScope(root);
                                        };

                Thread runner = new Thread(start);
                runner.Start();
        }

 public VisualScopeMarker(Graphics g, Scope scopeToDraw, ScopeAwareRichTextBox txt)
     : base(g, txt, 0,0)
 {
     if (scopeToDraw==null)
     {
         return;
     }
     startIndex = scopeToDraw.StartPosInRootScope;
     length = scopeToDraw.Length;
       drawnScope = scopeToDraw;
 }

 public List<Scope> AutoSplit(Scope root, int startIndexForWantedScope, int lengthOfWantedScope, bool isImplicit)
 {
     List<Scope> newScopes = new List<Scope>();
     List<SplitPoint> splitPoints = GetSplitPoints(root, startIndexForWantedScope, lengthOfWantedScope);
     foreach (SplitPoint splitPoint in splitPoints)
     {
         Scope newInnerScope = Split(root, splitPoint, isImplicit);
         newScopes.Add(newInnerScope);
     }
     return newScopes;
 }

 public void DefineInnerScope_InCombinedParentOfTwoInners_SetsRootScopeOnInner()
 {
     Scope root = new     Scope("0123456789");
     Scope parent = root.DefineInnerScope(5, 4);
     //5678
     Scope combinedParent = root.DefineInnerScope(5, 5);//5678+9
     Scope innerChild = root.DefineInnerScope(6, 2);//67
     Assert.AreEqual(combinedParent.InnerLeftScope, innerChild.ParentScope);
     Assert.AreEqual(combinedParent, combinedParent.InnerLeftScope.ParentScope);
     Assert.AreEqual(combinedParent, combinedParent.InnerRightScope.ParentScope);
 }

 public ScopeRenameAction(Scope scope, ScopeAwareRichTextBox text)
     : base(text, scope)
 {
     titlePrefix = "Rename";
     SetTitle();
     highlightFillColor = Color.Yellow;
     highlightFillOpacity = 80;
     highlightBorderColor = Color.Red;
     highlightBorderOpacity = 180;
     highlightBorderWidth = 2;
 }

        public void DefineInnerScope_WithleftMiddleandRightScopesasInner()
        {
            Scope root = new Scope("012345");
            root.DefineInnerScope(3, 1);//012|3|45
            ScopeSplitter splitter = new ScopeSplitter();
            splitter.AutoSplit(root, 2, 3, true);//01|(2|3|4)|5

            Scope encapsulator = root.DefineInnerScope(2, 3);
            Assert.AreEqual("2", encapsulator.InnerLeftScope.Text);
            Assert.AreEqual("3", encapsulator.InnerMiddleScope.Text);
            Assert.AreEqual("4", encapsulator.InnerRightScope.Text);
        }

        protected internal override void DrawCustomForSingleSurroundingRect(Rectangle rect, Scope scopeToDraw)
        {
            if (!IsActive && scopeToDraw.IsFlat && scopeToDraw.Name!=string.Empty)
            {
            //                new RegexMarker(graphics, scopeToDraw, RTB).DrawCustomForSingleSurroundingRect(rect, scopeToDraw);
                new GroupNameMarker(graphics, scopeToDraw, RTB).DrawCustomForSingleSurroundingRect(rect, scopeToDraw);
                return;
            }

            //            if (scopeToDraw.IsRoot && scopeToDraw.IsImplicit)
            //            {
            //                new VisualScopeInvisible(graphics, scopeToDraw, RTB).DrawCustomForSingleSurroundingRect(rect, scopeToDraw);
            //                return;
            //            }

            if (IsActive)
            {
                Scope namedParent = GetFirstNamedParentScopeFor(scopeToDraw);
                if (namedParent!=null)
                {
                    new NamedParentMarker(graphics, namedParent, RTB).DrawCustomForSingleSurroundingRect(rect, namedParent);
                }
                new VisualScopeActive(graphics, scopeToDraw, RTB).DrawCustomForSingleSurroundingRect(rect, scopeToDraw);

                return;
            }
            if (drawnScope.IsImplicit && drawnScope.IsFlat)
            {
            //                new VisualScopeImplicitFlat(graphics, scopeToDraw, RTB).DrawCustomForSingleSurroundingRect(rect, scopeToDraw);
                return;

            }

            //            if (drawnScope.IsImplicit && !drawnScope.IsFlat)
            //            {
            //                new NamedParentMarker(graphics, scopeToDraw, RTB).DrawCustomForSingleSurroundingRect(rect, scopeToDraw);
            //                return;
            //
            //            }
            if (!IsActive && drawnScope.IsExplicit && drawnScope.IsFlat)
            {
                new VisualScopeNonActiveNotImplicitFlat(graphics, scopeToDraw, RTB).DrawCustomForSingleSurroundingRect(rect, scopeToDraw);
                return;
            }

            if (IsActive && drawnScope.IsExplicit  && drawnScope.IsFlat)
            {
                new VisualScopeActiveNotImplicitFlat(graphics, scopeToDraw, RTB).DrawCustomForSingleSurroundingRect(rect, scopeToDraw);
                return;
            }
        }

        protected internal override void DrawCustomForSingleSurroundingRect(Rectangle rect, Scope scopeToDraw)
        {
            List<Rectangle> rects = txt.GetSurroundingRects(scopeToDraw.StartPosInRootScope,scopeToDraw.Length);
            int inflateFactor = 12;
            if(onMultipleLines(rects))
            {
                inflateFactor = 6;
            }
            foreach (Rectangle rec in rects)
            {
                Rectangle infaltedRect = GetInflated(true, rec, inflateFactor);
                txt.drawRectWithColor(infaltedRect,Color.Chocolate, graphics, 220,2);
            }

            return;
        }

 public List<Suggestion> GetSuggestions(Scope target)
 {
     RegexAdvisor advisor = new RegexAdvisor();
     advisor.MaxSuggestionLength = 45;
     TeachRules(advisor);
     string selection;
     if(target!=null)
     {
         selection = target.Text;
     }
     else
     {
         selection = txt.SelectedText;
     }
     return advisor.Suggest(selection);
 }

        protected internal override void DrawCustomForSingleSurroundingRect(Rectangle rect, Scope scopeToDraw)
        {
            DrawingParameters borderParameters = new DrawingParameters(Color.Empty, graphics, RTB.ImplicitScopeBorderColor, 35, RTB.NonActiveScopeBorderWidth);
            DrawingParameters fillParameters = new DrawingParameters(Color.Empty, graphics, 35);
            fillParameters.IsActive = IsActive;
            borderParameters.IsActive = IsActive;

            borderParameters.BorderColor = RTB.NonActiveScopeBorderColor;
            borderParameters.BorderWidth = RTB.NonActiveScopeBorderWidth;

            fillParameters.FillColor = RTB.NonActiveScopeFillColor;

            borderParameters.Rect = rect;
            fillParameters.Rect = rect;

            DrawBorder(borderParameters);
            DrawFill(fillParameters);
        }