private VarItem ImportVar(IBranch varBranch, bool native)
        {
            // protect ourselves from recursion
            if (varBranch == FormulaBeingEdited)
            {
                return null;
            }
            else
            {
                Func<String, String> attr = s => varBranch.GetValue(s) == null ? "" : varBranch.GetValue(s).ContentString;
                _varNames.Add(varBranch.VPath, attr("name"));
                _varTypes.Add(varBranch.VPath, attr("type"));
                var @newitem = new VarItem(varBranch, _varNames[varBranch.VPath], varBranch.VPath.ToElfIdentifier());

                if (native)
                {
                    _native.Add(@newitem);
                }
                else
                {
                    if (new VariableExpression(@newitem.InternalName).PieType() == PieType.Var)
                    {
                        _externalVars.Add(@newitem);
                    }
                    else
                    {
                        _externalNodes.Add(@newitem);
                    }
                }

                return @newitem;
            }
        }

        public TillerIntegrationContext(IBranch common, IBranch activeParticle, Func<IBranch> branchSelector, Func<IBranch> nodeSelector)
        {
            Common = common;
            FormulaBeingEdited = activeParticle;
            BranchSelector = branchSelector;
            NodeSelector = nodeSelector;

            var svds = Enumerable.Empty<IBranch>();
            if (FormulaBeingEdited != null)
            {
                var particle = FormulaBeingEdited.Parent.Parent;
                var partDecl = particle.GetBranches().SingleOrDefault(b => b.Name == "_sourceValueDeclarations");
                var partFlae = particle.GetBranches().SingleOrDefault(b => b.Name == "_formulaDeclarations");

                if (partFlae != null) svds = partFlae.AsArray().Concat(svds);
                if (partDecl != null) svds = partDecl.AsArray().Concat(svds);
            }

            Func<IBranch, String> type = b => b.GetValue("type") == null ? null : b.GetValue("type").ContentString;
            svds.Distinct().SelectMany(svd => svd.GetBranches())
                .Where(var => var != FormulaBeingEdited && type(var) != "text" && type(var) != "string")
                .ForEach(var => ImportVar(var));

            var elf = activeParticle.GetValue("elfCode") == null ? null : activeParticle.GetValue("elfCode").ContentString;
            if (elf != null) elf.RenderLightElfAsPublicText(this); // as a side effect this will fill in the externals
        }

        public static void SetOrderForBranch(INetwork network, IBranch branch)
        {
            // node is new if it is exclusive to branch
            var connectionsFromNodeCount = branch.Source.IncomingBranches.Count + branch.Source.OutgoingBranches.Count;
            var connectionsToNodeCount = branch.Target.IncomingBranches.Count + branch.Target.OutgoingBranches.Count;
            if (connectionsFromNodeCount == 1 && connectionsToNodeCount == 1)
            {
                // new branch, not connected (do not assign -1 since user might have assigned it when constructing object)
                return;
            }

            if(connectionsFromNodeCount > 2 || connectionsToNodeCount > 2)
            {
                branch.OrderNumber = -1;
                return;
            }
            if (connectionsFromNodeCount == 1 && connectionsToNodeCount == 2)
            {
                branch.OrderNumber = ComputeMaximumOrderForNode(network, branch.Target);
                return;
            }
            if (connectionsFromNodeCount == 2 && connectionsToNodeCount == 1)
            {
                branch.OrderNumber = ComputeMaximumOrderForNode(network, branch.Source);
                return;
            }
        }

        public ScenarionBrowser(BrowserMode mode, ScenarioDepot scenario, IBranch initialSelection, IBranch formulaBeingEdited)
        {
            InitializeComponent();

            Mode = mode;
            Text = mode == BrowserMode.SelectNode ? Resources.ScenarionBrowser_SelectNode : Resources.ScenarionBrowser_SelectBranch;

            Scenario = scenario;
            InitialSelection = initialSelection;
            FormulaBeingEdited = formulaBeingEdited;

						foreach (ScenarioNode root in Scenario)
						{
							LoadBranch(root, null);
						}


            var allNodes = treeScenario.Nodes.Cast<TreeNode>()
                .SelectMany(tn => tn.Flatten(n => n.Nodes.Cast<TreeNode>()));
            treeScenario.SelectedNode = allNodes.FirstOrDefault(n => n.Tag == initialSelection);

            tabControlBranchOptions.Visible = false;
            _emptySelectionTipRtb.Visible = true;
            splitContainer1.Panel2.Padding = new Padding(5, 5, 5, 5);
            ResyncOkAvailability();
        }

 public NetworkLocation(IBranch branch, double offset)
 {
     Branch = branch;
     Chainage = offset;
     
     var branchName = (branch != null ? branch.Name : "");
     Name = String.Format(CultureInfo.InvariantCulture, "{0}_{1:0.000}", branchName, offset);
 }

        public NetworkLocation(IBranch branch, double offset)
        {
            Branch = branch;
            Offset = offset;
            

            
        }

 /// <summary>
 ///     One or more items in the branch have changed
 /// </summary>
 /// <param name="changes">The fields that have changed</param>
 /// <param name="branch">The branch that has changed</param>
 /// <param name="startRow">The first index in the branch that changed</param>
 /// <param name="column">The column to update, or -1 for all columns</param>
 /// <param name="count">The number of items changed</param>
 public DisplayDataChangedData(VirtualTreeDisplayDataChanges changes, IBranch branch, int startRow, int column, int count)
 {
     myChanges = changes;
     myBranch = branch;
     myStartRow = startRow;
     myColumn = column;
     myCount = count;
 }

 internal VirtualTreeItemInfo(IBranch branch, int row, int column, int level)
 {
     myBranch = branch;
     myColumn = column;
     myRow = row;
     myLevel = level;
     myFlags = 0;
 }

 protected virtual IBranch Visit(IVault copyCat, IBranch branch)
 {
     var copy = copyCat.GetOrCreateBranch(branch.VPath);
     copy.SetEntireMetadata(branch.Metadata);
     branch.GetBranches().ForEach(b => Visit(copyCat, b));
     ((Branch)branch).GetValues(ValueKind.Regular).ForEach(v => Visit(copyCat, (IValue)v));
     ((Branch)branch).GetValues(ValueKind.Internal).ForEach(v => VisitInternal(copyCat, v));
     return copy;
 }

 public static XmlBranchDto FromBranch(IBranch branch)
 {
     return new XmlBranchDto 
     {
         Name = branch.Name,
         Metadata = ((Branch)branch).Metadata.Raw,
         Values = ((Branch)branch).GetValues(ValueKind.RegularAndInternal).Select(v => XmlValueDto.FromValue(v)).ToArray(),
         Branches = branch.GetBranches().Select(b => XmlBranchDto.FromBranch(b)).ToArray(),
     };
 }

 public object Eval(IBranch b)
 {
     if (Scenario != null)
     {
         var esath = Scenario.AssertNotNull().Eval(b.VPath);
         return esath.GetType().GetProperty("Val").GetValue(esath, null);
     }
     else
     {
         return Eval2.AssertNotNull().Eval(b);
     }
 }

 public int CompareTo(IBranch other)
 {
     if (this == other)
     {
         return 0;
     }
     if (Network.Branches.IndexOf(this) > Network.Branches.IndexOf(other))
     {
         return 1;
     }
     return -1;
 }

        public IObservable<IPullRequestModel> CreatePullRequest(IRepositoryHost host,
            ILocalRepositoryModel sourceRepository, IRepositoryModel targetRepository,
            IBranch sourceBranch, IBranch targetBranch,
            string title, string body
        )
        {
            Extensions.Guard.ArgumentNotNull(host, nameof(host));
            Extensions.Guard.ArgumentNotNull(sourceRepository, nameof(sourceRepository));
            Extensions.Guard.ArgumentNotNull(targetRepository, nameof(targetRepository));
            Extensions.Guard.ArgumentNotNull(sourceBranch, nameof(sourceBranch));
            Extensions.Guard.ArgumentNotNull(targetBranch, nameof(targetBranch));
            Extensions.Guard.ArgumentNotNull(title, nameof(title));
            Extensions.Guard.ArgumentNotNull(body, nameof(body));

            return PushAndCreatePR(host, sourceRepository, targetRepository, sourceBranch, targetBranch, title, body).ToObservable();
        }

        private static Expression ExpandRhs(IBranch b, IVault repository, List<Expression> stack, Dictionary<String, IBranch> nodes)
        {
            var elf = b.GetValue("elfCode").ContentString.ToCanonicalElf();
            var script = (Script)new ElfAstBuilder(elf).BuildAst();
            var assign = (AssignmentExpression)((ExpressionStatement)
                script.Classes.Single().Funcs.Single().Body.Statements.Single()).Expression;

            var rhs = assign.Expression;
            if (stack.Contains(rhs))
            {
                throw new EvalStackOverflowException();
            }
            else
            {
                stack.Add(rhs);
                return Expand(rhs, b.Vault, repository, stack, nodes);
            }
        }

        internal AggregateBranch(IList branchList, int primaryBranchIndex)
        {
            if (branchList == null)
            {
                throw new ArgumentNullException("branchList");
            }

            _primaryBranch = (IBranch)branchList[primaryBranchIndex];

            _branchList = new ArrayList(branchList.Count);
            foreach (var obj in branchList)
            {
                var branch = obj as IBranch;
                if (branch != null)
                {
                    _branchList.Add(branch);
                    branch.OnBranchModification += OnInnerBranchModification;
                }
                else
                {
                    throw new ArgumentException("branchList");
                }
            }
        }

 /// <summary>
 ///     Create a new child branch.
 /// </summary>
 internal ChildBranchInfo(IBranch branch, string name, object id)
 {
     _branch = branch;
     _name = name;
     _id = id;
 }

 public static IContentTypeAppliedToValue ApplyCType(IBranch parentOfNewValue, String typeToken)
 {
     var ctype = typeToken.GetCTypeFromToken().AssertNotNull();
     return ctype.Apply(parentOfNewValue);
 }

 /// <summary>
 ///     Remove all occurrences of branch from the tree. Note that removing all
 ///     items from a branch is not the same as removing the branch itself.
 /// </summary>
 /// <param name="branch">The branch to remove</param>
 /// <returns>An events args object for IBranch.OnBranchModification</returns>
 public static BranchModificationEventArgs RemoveBranch(IBranch branch)
 {
     return new BranchModificationMost(BranchModificationAction.RemoveBranch, branch);
 }

 /// <summary>
 ///     A mechanism for changing a cell from simple or expandable
 ///     to complex, or vice versa. This enables a potentially
 ///     complex cell to begin life as a simple cell, then switch later.
 ///     The makeComplex variable is interpreted according to the
 ///     cell style settings for the given branch.
 /// </summary>
 /// <param name="branch">The branch to modify</param>
 /// <param name="row">Target row</param>
 /// <param name="column">Target column</param>
 /// <param name="makeComplex">True to switch to a complex cell, false to switch to a simple cell</param>
 /// <returns>An events args object for IBranch.OnBranchModification</returns>
 public static BranchModificationEventArgs UpdateCellStyle(IBranch branch, int row, int column, bool makeComplex)
 {
     return new BranchModificationMost(BranchModificationAction.UpdateCellStyle, branch, row, column, makeComplex);
 }

 /// <summary>
 ///     Change the position of a single item in a branch
 /// </summary>
 /// <param name="branch">The branch where the item moved</param>
 /// <param name="fromRow">The row the item used to be on</param>
 /// <param name="toRow">The row the item is on now</param>
 /// <returns>An events args object for IBranch.OnBranchModification</returns>
 public static BranchModificationEventArgs MoveItem(IBranch branch, int fromRow, int toRow)
 {
     return new BranchModificationMost(BranchModificationAction.MoveItem, branch, fromRow, toRow);
 }