public void InstallFoldingManager()
		{
			var textEditorAdapter = textEditor as AvalonEditTextEditorAdapter;
			if (textEditorAdapter != null) {
				foldingManager = FoldingManager.Install(textEditorAdapter.TextEditor.TextArea);
			}
		}

 public MWindow()
 {
     try
     {
         InitializeComponent();
         Closing += new CancelEventHandler(MWindow_Closing);
         worker.DoWork += new DoWorkEventHandler(worker_DoWork);
         worker.RunWorkerCompleted += new RunWorkerCompletedEventHandler(worker_RunWorkerCompleted);
         dt.Interval = TimeSpan.FromSeconds(1);
         dt.Tick += new EventHandler(dt_Tick);
         foldingManager = FoldingManager.Install(textEditor.TextArea);
         foldingStrategy = new XmlFoldingStrategy();
         textEditor.TextChanged += new EventHandler(textEditor_TextChanged);
         if (App.StartUpCommand != "" && App.StartUpCommand != null)
         {
             openFile(App.StartUpCommand);
         }
         KeyGesture renderKeyGesture = new KeyGesture(Key.F5);
         KeyBinding renderCmdKeybinding = new KeyBinding(Commands.Render, renderKeyGesture);
         this.InputBindings.Add(renderCmdKeybinding);
         status.Text = "Ready!";
     }
     catch (Exception e)
     {
         MessageBox.Show(e.Message);
     }
 }

        public XamlPage()
        {
            InitializeComponent();

            textEditor.SyntaxHighlighting = HighlightingManager.Instance.GetDefinition("XML");
            TextEditorOptions options = textEditor.Options;
            if (options != null)
            {
                //options.AllowScrollBelowDocument = true;
                options.EnableHyperlinks = true;
                options.EnableEmailHyperlinks = true;
                //options.ShowSpaces = true;
                //options.ShowTabs = true;
                //options.ShowEndOfLine = true;
            }
            textEditor.ShowLineNumbers = true;

            _foldingManager  = FoldingManager.Install(textEditor.TextArea);
            _foldingStrategy = new XmlFoldingStrategy();

            textEditor.CommandBindings.Add(new CommandBinding(
                ApplicationCommands.Print, OnPrint, OnCanExecuteTextEditorCommand));
            textEditor.CommandBindings.Add(new CommandBinding(
                ApplicationCommands.PrintPreview, OnPrintPreview, OnCanExecuteTextEditorCommand));

            _searchHandler = new SearchInputHandler(textEditor.TextArea);
            textEditor.TextArea.DefaultInputHandler.NestedInputHandlers.Add(_searchHandler);
        }

        public MainForm() {
            InitializeComponent();

            // 初始化编辑器。
            codeEditor = new ICSharpCode.AvalonEdit.TextEditor();
            codeEditorHost.Child = codeEditor;

            codeEditor.FontFamily = new System.Windows.Media.FontFamily("Consolas");
            codeEditor.FontSize = 14;
            codeEditor.ShowLineNumbers = true;
            codeEditor.SyntaxHighlighting = syntaxHighlighting = HighlightingManager.Instance.GetDefinitionByExtension(".js");
            codeEditor.WordWrap = true;

            foldingManager = FoldingManager.Install(codeEditor.TextArea);
            codeEditor.TextChanged += codeEditor_TextChanged;

            //codeEditor.TextArea.AddHandler(System.Windows.DataObject.PastingEvent, new System.Windows.DataObjectPastingEventHandler(codeEditor_Paste));

            textMarkerService = new TextMarkerService(codeEditor);
            TextView textView = codeEditor.TextArea.TextView;
            textView.BackgroundRenderers.Add(textMarkerService);
            textView.LineTransformers.Add(textMarkerService);
            textView.Services.AddService(typeof(TextMarkerService), textMarkerService);
            textView.MouseHover += MouseHover;
            textView.MouseHoverStopped += codeEditorMouseHoverStopped;

            textView.MouseHover += MouseHover;
            textView.MouseHoverStopped += codeEditorMouseHoverStopped;
            textView.VisualLinesChanged += VisualLinesChanged;

        }

		/// <summary>
		/// Initializes a new instance of the <see cref="AvalonEditor"/> class.
		/// </summary>
		/// <exception cref="System.InvalidOperationException">Failed to load syntax definition</exception>
		public AvalonEditor()
		{
			_foldingManager = FoldingManager.Install(TextArea);
			_folding = new XmlFoldingStrategy();

			_htmlIndent = new HtmlIndentationStrategy();
			_defaultIndent = new DefaultIndentationStrategy();

			AutoIndent = true;
			AutoIndentAmount = 1;

			ShowLineNumbers = true;

			// Load our HTML highlighting
			using (var s = typeof(AvalonEditor).Assembly.GetManifestResourceStream(typeof(AvalonEditor), "HtmlHighlighting.xml"))
			{
				if (s == null)
					throw new InvalidOperationException("Failed to load syntax definition");
				using (var r = XmlReader.Create(s))
				{
					var highlightingDefinition = HighlightingLoader.Load(r, HighlightingManager.Instance);

					SyntaxHighlighting = highlightingDefinition;
				}
			}

            IsDirty = false;

            Task.Factory.StartNew(FoldingUpdateLoop);
		}

 public FoldingManagerAdapter(ITextEditor textEditor)
 {
     AvalonEditTextEditorAdapter adaptor = textEditor as AvalonEditTextEditorAdapter;
     if (adaptor != null) {
         this.foldingManager = FoldingManager.Install(adaptor.TextEditor.TextArea);
     }
 }

 public void Dispose()
 {
     if (foldingManager != null) {
         FoldingManager.Uninstall(foldingManager);
         foldingManager = null;
     }
 }

 public void ResetFoldingManager()
 {
   if (_foldingManager != null)
     FoldingManager.Uninstall(_foldingManager);
   _foldingManager = FoldingManager.Install(this.editor.TextArea);
   UpdateFoldings();
 }

 internal FoldingSection(FoldingManager manager, int startOffset, int endOffset)
 {
     Debug.Assert(manager != null);
     this.manager = manager;
     this.StartOffset = startOffset;
     this.Length = endOffset - startOffset;
 }

 public XmlMessageView()
 {
     InitializeComponent();
     foldingManager = FoldingManager.Install(document.TextArea);
     foldingStrategy = new XmlFoldingStrategy();
     SetValue(TextOptions.TextFormattingModeProperty, TextFormattingMode.Display);
     document.TextArea.IndentationStrategy = new ICSharpCode.AvalonEdit.Indentation.DefaultIndentationStrategy();
 }

 public JsonMessageView()
 {
     InitializeComponent();
     foldingManager = FoldingManager.Install(document.TextArea);
     foldingStrategy = new BraceFoldingStrategy();
     SetValue(TextOptions.TextFormattingModeProperty, TextFormattingMode.Display);
     document.TextArea.IndentationStrategy = new DefaultIndentationStrategy();
 }

 public DocumentDialog(string value)
 {
     InitializeComponent();
     this.jsonEditor.Text = value;
     this.jsonEditor.TextChanged += Te_TextChanged;
     foldingManager = FoldingManager.Install(this.jsonEditor.TextArea);
     foldingStrategy = new BraceFoldingStrategy();
     foldingStrategy.UpdateFoldings(foldingManager, jsonEditor.Document);
 }

        public APITestDialog()
        {
            InitializeComponent();

             foldingManager = FoldingManager.Install(xmlViewer.TextArea);
             foldingStrategy = new XmlFoldingStrategy();

             LoadAPICalls();
        }

        /// <summary>
        /// Determine whether or not highlighting can be
        /// suppported by a particular folding strategy.
        /// </summary>
        /// <param name="syntaxHighlighting"></param>
        public void SetFolding(IHighlightingDefinition syntaxHighlighting)
        {
            if (syntaxHighlighting == null)
              {
            this.mFoldingStrategy = null;
              }
              else
              {
            switch (syntaxHighlighting.Name)
            {
              case "XML":
              case "HTML":
            mFoldingStrategy = new XmlFoldingStrategy() { ShowAttributesWhenFolded = true };
            this.TextArea.IndentationStrategy = new ICSharpCode.AvalonEdit.Indentation.DefaultIndentationStrategy();
            break;
              case "C#":
            this.TextArea.IndentationStrategy = new ICSharpCode.AvalonEdit.Indentation.CSharp.CSharpIndentationStrategy(this.Options);
            mFoldingStrategy = new CSharpBraceFoldingStrategy();
            break;
              case "C++":
              case "PHP":
              case "Java":
            this.TextArea.IndentationStrategy = new ICSharpCode.AvalonEdit.Indentation.CSharp.CSharpIndentationStrategy(this.Options);
            mFoldingStrategy = new CSharpBraceFoldingStrategy();
            break;
              case "VBNET":
            this.TextArea.IndentationStrategy = new ICSharpCode.AvalonEdit.Indentation.CSharp.CSharpIndentationStrategy(this.Options);
            mFoldingStrategy = new VBNetFoldingStrategy();
            break;
              default:
            this.TextArea.IndentationStrategy = new ICSharpCode.AvalonEdit.Indentation.DefaultIndentationStrategy();
            mFoldingStrategy = null;
            break;
            }

            if (mFoldingStrategy != null)
            {
              if (this.Document != null)
              {
            if (mFoldingManager == null)
              mFoldingManager = FoldingManager.Install(this.TextArea);

            this.mFoldingStrategy.UpdateFoldings(mFoldingManager, this.Document);
              }
              else
            this.mInstallFoldingManager = true;
            }
            else
            {
              if (mFoldingManager != null)
              {
            FoldingManager.Uninstall(mFoldingManager);
            mFoldingManager = null;
              }
            }
              }
        }

        public TextEditorControl(string name, int index)
        {
            InitializeComponent();

            FileName = name;
            FileIndex = index;

            var foldingUpdateTimer = new DispatcherTimer {Interval = TimeSpan.FromSeconds(2)};
            foldingUpdateTimer.Tick += FoldingUpdateTimerTick;
            foldingUpdateTimer.Start();

            if (File.Exists(@"Highlighter\CustomHighlighting.xshd"))
            {
                var fileStream = new FileStream(@"Highlighter\CustomHighlighting.xshd", FileMode.Open, FileAccess.Read);
                using (var reader = new XmlTextReader(fileStream))
                {
                    textEditor.SyntaxHighlighting = HighlightingLoader.Load(reader, HighlightingManager.Instance);
                }
                fileStream.Close();
            }

            textEditor.TextArea.IndentationStrategy =
                new CSharpIndentationStrategy(textEditor.Options);
            _foldingStrategy = new BEFoldingStrategy();

            if (_foldingStrategy != null)
            {
                if (_foldingManager == null)
                    _foldingManager = FoldingManager.Install(textEditor.TextArea);
                _foldingStrategy.UpdateFoldings(_foldingManager, textEditor.Document);
            }
            else
            {
                if (_foldingManager != null)
                {
                    FoldingManager.Uninstall(_foldingManager);
                    _foldingManager = null;
                }
            }

            textEditor.Text = "# Welcome to lpSolver (Linear Programming Solver)!" + Environment.NewLine;
            textEditor.Text += "lpmodel ModelName" + FileIndex.ToString() + " \n{" + Environment.NewLine;
            textEditor.Text += string.Format("\t# TODO : Objectives {0}{0}", Environment.NewLine + "\t");

            textEditor.Text += "min 10*x + 20*y" + Environment.NewLine;
            textEditor.Text += "\tsubject to:" + Environment.NewLine;
            textEditor.Text += "\tx + y > 10;" + Environment.NewLine;
            textEditor.Text += "\t0<x;" + Environment.NewLine;
            textEditor.Text += "\t0<y;" + Environment.NewLine;
            textEditor.Text += Environment.NewLine + "\t";
            textEditor.Text += Environment.NewLine;
            textEditor.Text += "};" + Environment.NewLine;
            textEditor.Text += "# __EOF" + Environment.NewLine;

            textEditor.ShowLineNumbers = true;
            FileUrl = string.Empty;
        }

        public void UpdateFoldings(FoldingManager manager, ITextSource document)
        {
            if (manager == null)
                throw new ArgumentNullException("manager");

            int firstErrorOffset;
            IEnumerable<NewFolding> newFoldings = CreateNewFoldings(document, out firstErrorOffset);
            manager.UpdateFoldings(newFoldings, firstErrorOffset);
        }

        public GeneratedCodeView()
        {

            // Load our custom highlighting definition
            IHighlightingDefinition customHighlighting;
            using (Stream s = typeof(GeneratedCodeView).Assembly.GetManifestResourceStream("CinchCodeGen.UserControls.CustomHighlighting.xshd"))
            {
                if (s == null)
                    throw new InvalidOperationException("Could not find embedded resource");
                using (XmlReader reader = new XmlTextReader(s))
                {
                    customHighlighting = ICSharpCode.AvalonEdit.Highlighting.Xshd.
                        HighlightingLoader.Load(reader, HighlightingManager.Instance);
                }
            }
            // and register it in the HighlightingManager
            HighlightingManager.Instance.RegisterHighlighting("Custom Highlighting", new string[] { ".cool" }, customHighlighting);



            InitializeComponent();

            txtCode.SyntaxHighlighting = customHighlighting;

            if (txtCode.SyntaxHighlighting == null)
            {
                foldingStrategy = null;
            }
            else
            {
                foldingStrategy = new BraceFoldingStrategy();
            }

            if (foldingStrategy != null)
            {
                if (foldingManager == null)
                    foldingManager = FoldingManager.Install(txtCode.TextArea);
                foldingStrategy.UpdateFoldings(foldingManager, txtCode.Document);
            }
            else
            {
                if (foldingManager != null)
                {
                    FoldingManager.Uninstall(foldingManager);
                    foldingManager = null;
                }
            }

            DispatcherTimer foldingUpdateTimer = new DispatcherTimer();
            foldingUpdateTimer.Interval = TimeSpan.FromSeconds(2);
            foldingUpdateTimer.Tick += foldingUpdateTimer_Tick;
            foldingUpdateTimer.Start();


            this.DataContextChanged += GeneratedCodeView_DataContextChanged;
        }

        public SagaContentViewer()
        {
            InitializeComponent();

            foldingManager = FoldingManager.Install(document.TextArea);
            foldingStrategy = new BraceFoldingStrategy();
            SetValue(TextOptions.TextFormattingModeProperty, TextFormattingMode.Display);
            document.TextArea.IndentationStrategy = new ICSharpCode.AvalonEdit.Indentation.DefaultIndentationStrategy();
            document.TextChanged += DocumentOnTextChanged;
        }

        public void UpdateFoldings(FoldingManager foldingManager, TextDocument textDocument)
        {
            // Clear foldings if the list isn't empty.
            if (this.foldings.Foldings.Count > 0)
            {
                this.foldings.Foldings.Clear();
            }

            CreateNewFoldings(textDocument);
            foldingManager.UpdateFoldings(this.foldings.Foldings, this.foldings.FirstErrorOffset);
        }

        //BraceFoldingStrategy foldingStrategy;
        public TextEditor()
        {
            InitializeComponent();

              // CodeLanguage = NServiceBus.Profiler.Common.CodeParser.CodeLanguage.Plain;

              // -- AvalonEdit
              foldingManager = FoldingManager.Install(doc.TextArea);
              //foldingStrategy = new BraceFoldingStrategy();
              SetValue(TextOptions.TextFormattingModeProperty, TextFormattingMode.Display);
              doc.TextArea.IndentationStrategy = new DefaultIndentationStrategy();
        }