<Window x:Class="TestMakeOutline833.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Window1" Height="300" Width="650">
    <Window.Resources>
        <HierarchicalDataTemplate x:Key="sectionTemplate"
            ItemsSource="{Binding OutlineObjects}">
            <StackPanel Orientation="Horizontal">
                <TextBlock Text="{Binding Line}" />
            </StackPanel>
        </HierarchicalDataTemplate>
    </Window.Resources>
    <StackPanel Margin="10">
        <StackPanel Orientation="Horizontal" Margin="0 0 0 10">

            <ScrollViewer
                Width="300"
                Height="200"
                Margin="0 0 10 0">
                <TextBox
                    x:Name="MainTextBox"
                    AcceptsReturn="True"
                    AcceptsTab="True"

                    Text="{Binding OutlineText}"/>
            </ScrollViewer>

            <TreeView ItemsSource="{Binding OutlineObjects}"
                Width="200"
                Height="200"
                ItemTemplate="{StaticResource sectionTemplate}">
            </TreeView>

        </StackPanel>
        <StackPanel HorizontalAlignment="Left">
            <Button Content="Convert Text to Outline" Click="Button_Click_Convert"/>
        </StackPanel>
    </StackPanel>
</Window>

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Documents;
using System.ComponentModel;
using System.Collections.ObjectModel;

namespace TestMakeOutline833
{
    public partial class Window1 : Window, INotifyPropertyChanged
    {
        #region ViewModelProperty: OutlineText
        private string _outlineText;
        public string OutlineText
        {
            get
            {
                return _outlineText;
            }

            set
            {
                _outlineText = value;
                OnPropertyChanged("OutlineText");
            }
        }
        #endregion //

        #region ViewModelProperty: OutlineObjects
        private ObservableCollection<OutlineObject> _outlineObjects = new ObservableCollection<OutlineObject>();
        public ObservableCollection<OutlineObject> OutlineObjects
        {
            get
            {
                return _outlineObjects;
            }

            set
            {
                _outlineObjects = value;
                OnPropertyChanged("OutlineObjects");
            }
        }
        #endregion //

        public Window1()
        {
            InitializeComponent();
            DataContext = this;

            OutlineText = StringHelpers.GetDefaultTextBlock();
            MainTextBox.Focus();
            BuildOutline();
        }

        #region INotifiedProperty Block
        public event PropertyChangedEventHandler PropertyChanged;

        protected void OnPropertyChanged(string propertyName)
        {
            PropertyChangedEventHandler handler = PropertyChanged;

            if (handler != null)
            {
                handler(this, new PropertyChangedEventArgs(propertyName));
            }
        }
        #endregion //

        void Button_Click_Convert(object sender, RoutedEventArgs e)
        {
            BuildOutline();
        }

        void BuildOutline()
        {
            OutlineObjects.Clear();
            OutlineManager om = new OutlineManager(OutlineText);

            foreach (var outlineObject in om.OutlineObjects)
            {
                OutlineObjects.Add(outlineObject);
            }
        }
    }

    public class OutlineManager
    {
        private string outlineBlock;
        private List<string> outlineBlockLines;

        public List<OutlineObject> OutlineObjects { get; set; }

        public OutlineManager(string outlineBlock)
        {
            this.outlineBlock = outlineBlock;
            this.outlineBlockLines = StringHelpers.ConvertBlockToLines(outlineBlock);
            OutlineObjects = new List<OutlineObject>();
            ProcessOutline();
        }

        void ProcessOutline()
        {
            //convert file contents to object collection
            Stack<OutlineObject> parents = new Stack<OutlineObject>();
            int lastLevel = 0;
            foreach (var line in outlineBlockLines)
            {
                OutlineObject oo = new OutlineObject(line);

                if (oo.Level == 0)
                {
                    //root element
                    OutlineObjects.Add(oo);
                    parents.Push(oo);
                    lastLevel = 0;
                }
                else if (oo.Level - lastLevel > 1)
                {
                    //skipped generation(s)
                    throw new Exception("outline structure invalid");
                }
                else if (oo.Level - lastLevel == 1)
                {
                    //child element
                    OutlineObject topObject = parents.Peek();
                    topObject.OutlineObjects.Add(oo);
                    parents.Push(oo);
                    lastLevel++;
                }
                else if (oo.Level == lastLevel)
                {
                    //sibling element
                    parents.Pop();
                    OutlineObject topObject = parents.Peek();
                    topObject.OutlineObjects.Add(oo);
                    parents.Push(oo);
                }
                else if (oo.Level < lastLevel)
                {
                    int levelDifference = lastLevel - oo.Level;
                    for (int i = 0; i < levelDifference + 1; i++)
                    {
                        parents.Pop();
                    }
                    OutlineObject topObject = parents.Peek();
                    topObject.OutlineObjects.Add(oo);
                    parents.Push(oo);
                    lastLevel = oo.Level;
                }
            }
        }

        public static List<OutlineObject> GetOutline(string block)
        {
            OutlineManager om = new OutlineManager(block);
            return om.OutlineObjects;
        }
    }

    public class OutlineObject
    {
        public List<OutlineObject> OutlineObjects { get; set; }
        public string Line { get; set; }
        public int Level { get; set; }

        public OutlineObject(string rawLine)
        {
            OutlineObjects = new List<OutlineObject>();
            Level = rawLine.CountPrecedingDashes();
            Line = rawLine.Trim(new char[] { '-', ' ', 't' });
        }
    }

    public static class StringHelpers
    {
        public static string GetDefaultTextBlock()
        {
            return "countries" + Environment.NewLine +
                "tfrance" + Environment.NewLine +
                "ttparis" + Environment.NewLine +
                "ttbordeaux" + Environment.NewLine +
                "tgermany" + Environment.NewLine +
                "tthamburg" + Environment.NewLine +
                "ttberlin" + Environment.NewLine +
                "tthannover" + Environment.NewLine +
                "ttmunich" + Environment.NewLine +
                "titaly" + Environment.NewLine +
                "subjects" + Environment.NewLine +
                "tmath" + Environment.NewLine +
                "ttalgebra" + Environment.NewLine +
                "ttcalculus" + Environment.NewLine +
                "tscience" + Environment.NewLine +
                "ttchemistry" + Environment.NewLine +
                "ttbiology" + Environment.NewLine +
                "other" + Environment.NewLine +
                "tthis" + Environment.NewLine +
                "tthat";
        }

        public static int CountPrecedingDashes(this string line)
        {
            int tabs = 0;
            StringBuilder sb = new StringBuilder();
            foreach (var c in line)
            {
                if (c == 't')
                    tabs++;
                else
                    break;
            }
            return tabs;
        }

        public static List<string> ConvertBlockToLines(this string block)
        {
            string fixedBlock = block.Replace(Environment.NewLine, "§");
            List<string> lines = fixedBlock.Split('§').ToList<string>();
            lines.ForEach(s => s = s.Trim());
            lines.TrimBlankLines();

            return lines;
        }

        public static void TrimBlankLines(this List<string> list)
        {
            while (0 != list.Count && string.IsNullOrEmpty(list[0]))
            {
                list.RemoveAt(0);
            }
            while (0 != list.Count && string.IsNullOrEmpty(list[list.Count - 1]))
            {
                list.RemoveAt(list.Count - 1);
            }
        }
    }
}