void MakeTables(TreeList<CellBase> result)
        {
            string leader = string.Empty;
            TreeList<CellBase> table = null;
            scanner.MoveNext();
            do {
                if (scanner.Current.Type == TokenType.Leader) {
                    leader = scanner.Current.Content;
                    scanner.MoveNext();
                }
                else if (scanner.Current.Type == TokenType.Word) {
                    table = new TreeList<CellBase>(new CellBase(string.Empty));
                    table.Value.SetAttribute(CellAttribute.StartTag, "<p>");
                    table.Value.SetAttribute(CellAttribute.EndTag, "</p>");
                    if (leader.Length > 0) {
                        table.Value.SetAttribute(CellAttribute.Leader, leader);
                        leader = string.Empty;
                    }
                    result.AddBranch(table);
                    MakeRows(table);
                    if (scanner.Current.Type == TokenType.Newline) scanner.MoveNext();
                }
                else {
                    scanner.MoveNext();
                }
            } while (scanner.Current.Type != TokenType.End);

            if (table != null && scanner.Current.Content.Length > 0) {
                 table.Value.SetAttribute(CellAttribute.Trailer, scanner.Current.Content);
            }
        }

        public static void SetCellDisableTree(TreeList tree,string FieldName,string KeyField,long[]KeyValues)
        {
            tree.CustomDrawNodeCell += delegate(object sender, CustomDrawNodeCellEventArgs e) {
                if (e.Node == tree.FocusedNode) {
                    return;
                }

                if (e.Column.FieldName == FieldName)
                {
                    for (int vt = 0; vt <= KeyValues.Length - 1; vt++)
                    {
                        if (Convert.ToInt64(e.Node.GetValue(KeyField)) == KeyValues[vt])
                        {
                            e.Appearance.BackColor = Color.LightGray;
                        }
                    }
                }
            };
            tree.ShowingEditor += delegate(object sender, CancelEventArgs e) {
                TreeListNode note = tree.FocusedNode;
                if (note != null)
                {
                    for (int vt = 0; vt <= KeyValues.Length - 1; vt++)
                    {
                        if (Convert.ToInt64(note.GetValue(KeyField)) == KeyValues[vt]
                            && tree.FocusedColumn.FieldName == FieldName)
                        {
                            e.Cancel = true;
                        }
                    }
                }
            };
        }

        public RepositoryPLGridSelect(XtraForm frmDanhMuc, string columnField, string tableName, string ValueField, string[] visibleField, string[] caption, string getField, TreeList treeList)
        {
            init();
            plDanhMuc.TreeList = treeList;
            plDanhMuc._init(frmDanhMuc ,columnField, tableName , ValueField , visibleField , caption , getField);

            treeList.GotFocus += delegate(object sender , EventArgs e)
            {
                if (treeList.DataSource != null &&
                        !((DataTable)treeList.DataSource).Columns.Contains(columnField + getField))
                {
                    ((DataTable)treeList.DataSource).Columns.Add(new DataColumn(columnField + getField));
                }
            };
            treeList.CellValueChanged += delegate(object sender , CellValueChangedEventArgs e)
            {
                if (e.Column.FieldName.Equals(columnField+getField))
                {
                    DataRowView rowView = (DataRowView)treeList.GetDataRecordByNode(e.Node);
                    DataRow row = rowView.Row;
                    row[columnField] = _getId(e.Value);
                }
            };
            this.Popup += new EventHandler(RepositoryHuyDanhMuc_Popup);
            this.Leave += new EventHandler(RepositoryDanhMucAdv_Leave);
        }

        public override System.Drawing.Image GetImage(object element, TreeList.Column column)
        {
            if (element.GetType() == typeof(WorkoutWrapper))
            {
                WorkoutWrapper wrapper = (WorkoutWrapper)element;

                if (((Workout)wrapper.Element).IsDirty)
                {
                    return global::GarminFitnessPlugin.Resources.Resources.WorkoutDirtyIcon;
                }
                else if (((Workout)wrapper.Element).ContainsFITOnlyFeatures)
                {
                    return global::GarminFitnessPlugin.Resources.Resources.FITWorkoutIcon;
                }

                return global::GarminFitnessPlugin.Resources.Resources.WorkoutIcon;
            }
            if (element.GetType() == typeof(WorkoutPartWrapper))
            {
                return global::GarminFitnessPlugin.Resources.Resources.WorkoutPartIcon;
            }
            else if (element.GetType() == typeof(ActivityCategoryWrapper))
            {
                return global::GarminFitnessPlugin.Resources.Resources.CategoryIcon;
            }

            return base.GetImage(element, column);
        }

 public void ExecuteImportAddsNamespace()
 {
     var executeImport = new ExecuteImport();
     var input = new TreeList<string>().AddBranchValue("step").AddBranchValue("import").AddBranchValue("fitnesse.unitTest.slim");
     ExecuteOperation(executeImport, input, 2);
     Assert.IsTrue(processor.Create("SampleClass").Value is SampleClass);
 }

 public void ExecuteDefaultReturnsException()
 {
     var executeDefault = new ExecuteDefault();
     var input = new TreeList<string>().AddBranchValue("step").AddBranchValue("garbage");
     ExecuteOperation(executeDefault, input, 2);
     CheckForException("message<<MALFORMED_INSTRUCTION step,garbage>>");
 }

        public virtual void PaintCell(Graphics dc, 
            Rectangle cellRect,
            Node node,
            TreeListColumn column,
            TreeList.TextFormatting format,
            object data)
        {
            if (format.BackColor != Color.Transparent)
            {
                Rectangle r = cellRect;
                r.X = column.CalculatedRect.X;
                r.Width = column.CalculatedRect.Width;
                SolidBrush brush = new SolidBrush(format.BackColor);
                dc.FillRectangle(brush, r);
                brush.Dispose();
            }
            if (data != null)
            {
                cellRect = CommonTools.Util.AdjustRectangle(cellRect, format.Padding);
                //dc.DrawRectangle(Pens.Black, cellRect);

                Color color = format.ForeColor;
                if (m_owner.FocusedNode == node && Application.RenderWithVisualStyles  == false)
                    color = SystemColors.HighlightText;
                TextFormatFlags flags= TextFormatFlags.EndEllipsis | format.GetFormattingFlags();
                TextRenderer.DrawText(dc, data.ToString(), m_owner.Font, cellRect, color, flags);
            }
        }

 public void ExecuteMakeBadClassReturnsException()
 {
     var executeMake = new ExecuteMake();
     var input = new TreeList<string>().AddBranchValue("step").AddBranchValue("make").AddBranchValue("variable").AddBranchValue("garbage");
     ExecuteOperation(executeMake, input, 2);
     CheckForException("message<<NO_CLASS garbage>>");
 }

 public Tree<CellBase> Parse(string input)
 {
     scanner = new TextTableScanner(input);
     var result = new TreeList<CellBase>(new CellBase(string.Empty));
     MakeTables(result);
     return result;
 }

 public TreeListNode AddTreeListNode(TreeList treelist, TreeListNode node, Type type, string propertyName, string defaultFunction, string validationFunction)
 {
     TreeListNode newNode = treelist.AppendNode(new object[] { propertyName, defaultFunction, validationFunction }, node);
     //newNode.ImageIndex = newNode.SelectImageIndex = (int)image;
     newNode.Tag = type;
     return newNode;
 }

 public bool GetEnableMouseMulSelect(TreeList treeList)
 {
     if (list.ContainsKey(treeList))
     {
         return list[treeList].EnableMouseMulSelect;
     }
     return false;
 }

 public bool GetShowLineNo(TreeList treelist)
 {
     if (StyleList.ContainsKey(treelist))
     {
         return StyleList[treelist].EnableLineNo;
     }
     return true;
 }

 public string GetLineNoFormatString(TreeList treelist)
 {
     if (StyleList.ContainsKey(treelist))
     {
         return StyleList[treelist].LineNoFormatString;
     }
     return "{0}";
 }

 public bool GetEnableCommonStyle(TreeList treelist)
 {
     if (this.list.ContainsKey(treelist))
     {
         return list[treelist].EnableCommonStyle;
     }
     return true;
 }

 public DashboardListPresenter(TreeList tree, DashboardsFilterPaneViewModel viewModel)
 {
     _viewModel = viewModel;
     _tree = tree;
     InitTree();
     PopulateTree();
     Messenger.Default.Register<DashboardMessage>(this, OnDashboardMessage);
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="XtraTreeListPrintAdapter"/> class.
        /// </summary>
        /// <param name="adaptee">The adaptee.</param>
        /// <param name="workItem">The work item.</param>
        public XtraTreeListPrintAdapter(TreeList adaptee, WorkItem workItem)
        {
            this.adaptee = adaptee;
            this.workItem = workItem;
            xtrapService = new XtraPrintService(adaptee, adaptee.Text);

            RegisterEvent();
        }

 static Tree<string> NodeParameters(XmlNode node) {
     var result = new TreeList<string>()
         .AddBranchValue(node.InnerText);
     foreach (XmlAttribute attribute in node.Attributes) {
         result.AddBranchValue(attribute.Value);
     }
     return result;
 }

 public bool GetEnableHotTrack(TreeList treeList)
 {
     if (List.ContainsKey(treeList))
     {
         return List[treeList].EnableHotTrack;
     }
     return false;
 }

 public Color GetHotTrackColor(TreeList treeList)
 {
     if (List.ContainsKey(treeList))
     {
         return List[treeList].HotTrackColor;
     }
     return Color.FromArgb(213, 232, 255);
 }

 public void ExecuteCallBadMethodReturnsException()
 {
     processor.Store(new SavedInstance("variable", new SampleClass()));
     var executeCall = new ExecuteCall();
     var input = new TreeList<string>().AddBranchValue("step").AddBranchValue("call").AddBranchValue("variable").AddBranchValue("garbage");
     ExecuteOperation(executeCall, input, 2);
     CheckForException("message<<NO_METHOD_IN_CLASS garbage fitnesse.unitTest.slim.SampleClass>>");
 }