public static void ShowObject(Nodes.Node.ObjectPair obj)
        {
            BehaviorTreeList behaviorTreeList = BehaviorManager.Instance as BehaviorTreeList;
            if (behaviorTreeList == null)
                return;

            Nodes.Node node = null;
            Attachments.Attachment attach = null;
            if (obj.Obj is Nodes.Node)
            {
                node = (Nodes.Node)obj.Obj;
            }
            else if (obj.Obj is Attachments.Attachment)
            {
                attach = (Attachments.Attachment)obj.Obj;
                node = attach.Node;
            }

            if (node != null)
            {
                behaviorTreeList.ShowNode(node, obj.Root);
                if (BehaviorTreeViewDock.LastFocused != null)
                {
                    BehaviorTreeView behaviorTreeView = BehaviorTreeViewDock.LastFocused.BehaviorTreeView;
                    if (behaviorTreeView != null)
                    {
                        behaviorTreeView.SelectedNodePending = node;
                        behaviorTreeView.SelectedAttachmentPending = attach;

                        behaviorTreeView.Refresh();
                    }
                }
            }
        }

        public string type = ""; // type of undo operation (delete, create, edit, move, changeLineColor, changeLineWidth, changeNodeColor)

        #endregion Fields

        #region Constructors

        /*************************************************************************************************************************/
        // CONSTRUCTORS
        public UndoOperation(
            string type, 
            Nodes nodes = null, 
            Lines lines = null, 
            int group = 0, 
            Position position = null, 
            int layer = 0
        )
        {
            this.type = type;
            this.group = group;
            this.position.set(position);
            this.layer = layer;

            if (nodes != null)
            {
                foreach (Node node in nodes)
                {
                    this.nodes.Add(new Node(node));
                }
            }

            if (lines != null)
            {
                foreach (Line line in lines)
                {
                    this.lines.Add(new Line(line));
                }
            }
        }

        public static string hitJoint(Nodes.Node n, Rectangle rect, int x, int y, bool inputsOnly) {
            //assume using a padded rect
            //missed the balls.
            if (x > rect.Left + ballSize && x < rect.Right - ballSize)
                return null;

            rect.Y += nodeTitleFont.Height;
            if (n.getExtra() != null) {
                rect.Y += nodeExtraFont.Height;
            }

            if (y < rect.Y)
                return null;

            Point pos;
            foreach (var kvp in n.getProperties()) {
                if ((kvp.Value.isInput && inputsOnly) || (kvp.Value.isOutput && !inputsOnly)) {
                    pos = getJointPos(n, kvp.Key, inputsOnly);
                    pos.X -= x; pos.Y -= y;

                    //intentionally dividing by 2 instead of 4 to expand the 'okay' selection radius.
                    if (pos.X * pos.X + pos.Y * pos.Y < ballSize * ballSize / 2) {
                        return kvp.Key;
                    }
                }
            }

            return null;
        }

        public void SetPar(ParInfo par, Nodes.Node rootNode, bool isNewPar)
        {
            Debug.Check(par != null && rootNode != null);

            _isNewPar = isNewPar;
            _initialized = false;

            this.Text = isNewPar ? Resources.NewPar : Resources.EditPar;

            _par = par;
            _parTemp = par.Clone();
            _rootNode = rootNode;

            setParTypes();

            if (par != null) {
                _isArray = Plugin.IsArrayType(par.Type);
                Type type = _isArray ? par.Type.GetGenericArguments()[0] : par.Type;

                nameTextBox.Text = par.Name;
                arrayCheckBox.Checked = _isArray;
                typeComboBox.Text = Plugin.GetMemberValueTypeName(type);
                descTextBox.Text = par.BasicDescription;

                setValue(type);
            }

            enableOkButton();

            _initialized = true;
        }

        protected override Tags.Base ResolveSpecific(Nodes.Base node)
        {
            if (node is Nodes.Mapping)
                return new Tags.Mapping();
            if (node is Nodes.Sequence)
                return new Tags.Sequence();

            var scalarNode = (Nodes.Scalar)node;

            var value = scalarNode.Content;

            switch (value)
            {
                case "null":
                    return new Tags.Null();
                case "true":
                case "false":
                    return new Tags.Boolean();
            }

            if (intExpression.IsMatch(value))
                return new Tags.Integer();
            if (floatExpression.IsMatch(value))
                return new Tags.FloatingPoint();

            return null;
        }

 /// <summary>
 /// Creates a new exporter.
 /// </summary>
 /// <param name="node">The behaviour hich will be exported.</param>
 /// <param name="outputFolder">The folder we want to export the behaviour to.</param>
 /// <param name="filename">The relative filename we want to export to. You have to add your file extension.</param>
 public Exporter(Nodes.BehaviorNode node, string outputFolder, string filename, List<string> includedFilenames = null)
 {
     _node = node;
     _outputFolder = outputFolder;
     _filename = filename;
     _includedFilenames = includedFilenames;
 }

        public override void RenderChildren(IParrotWriter writer, Nodes.Statement statement, IRendererFactory rendererFactory, IDictionary<string, object> documentHost, object model, string defaultTag = null)
        {
            if (string.IsNullOrEmpty(defaultTag))
            {
                defaultTag = DefaultChildTag;
            }

            //get model from parameter
            //required - do not remove
            if (statement.Parameters != null && statement.Parameters.Count == 1)
            {
                var localModel = GetLocalModel(documentHost, statement, model);

                if (localModel is IEnumerable)
                {
                    //create locals object to handle local values to the method
                    Locals locals = new Locals(documentHost);

                    IList<object> items = ToList(model as IEnumerable);
                    for (int i = 0; i < items.Count; i++)
                    {
                        var localItem = items[i];
                        locals.Push(IteratorItem(i, items));

                        base.RenderChildren(writer, statement.Children, rendererFactory, documentHost, defaultTag, localItem);

                        locals.Pop();
                    }
                }
            }
            else
            {
                base.RenderChildren(writer, statement.Children, rendererFactory, documentHost, defaultTag, model);
            }
        }

        private static Nodes.Assignment ArrayAssignment(Lexer.Lexem currLexem, Nodes.Node.Coords coords)
        {
            Nodes.Expression index = Expr();
            if (Lexer.LookAhead().LexType != Lexer.LexType.CloseSquadBracket)
                ErrorList.Add(new Error(ParserException.NeedCloseSquadBracket, Lexer.LookBack().EndCoords));
            else
                Lexer.NextLexem();

            if (Lexer.LookAhead().LexType == Lexer.LexType.EqualSign)
            {
                Lexer.NextLexem();
                Nodes.Expression value = Expr();
                /*if (Lexer.LookAhead().LexType != Lexer.LexType.Semicolon)
                    ErrorList.Add(new Error(ParserException.NeedSemicolon, Lexer.LookBack().EndCoords));
                else
                    Lexer.NextLexem();*/
                Nodes.Assignment result = new Nodes.Assignment(new Nodes.ElementOfArray(currLexem.VarName, index), value, coords);
                result.Head = result;
                result.Tail = result;
                return result;
            }
            else
            {
                while (Lexer.LookBack().LexType != Lexer.LexType.Variable)
                    Lexer.RollBack();
                Lexer.RollBack();
                return null;
            }
        }

 /// <summary>
 /// Creates an instance of <see cref="NodeUserControl"/> class.
 /// </summary>
 public NodeUserControl()
 {
     InitializeComponent();
     m_dataContext = new Nodes(16);
     m_dataContext.PropertyChanged += new PropertyChangedEventHandler(ViewModel_PropertyChanged);
     this.DataContext = m_dataContext;
 }

 public Assignment(ElementOfArray array, Nodes.Expression expr, Node.Coords coords)
 {
     Var = null;
     Value = expr;
     Array = array;
     this.Coords = coords;
 }

        public void InspectObject(AgentType agentType, string agentFullname, Nodes.Node node)
        {
            _agentFullname = agentFullname;

            preLayout();

            deleteAllRowControls();

            if (agentType != null)
            {
                IList<PropertyDef> properties = agentType.GetProperties();
                foreach (PropertyDef p in properties)
                {
                    addRowControl(p, null);
                }
            }
            else if (node != null)
            {
                List<ParInfo> allPars = node.Pars;
                foreach (ParInfo par in allPars)
                {
                    addRowControl(null, par);
                }
            }

            postLayout();
        }

        public Leader(IElection election, 
            IHartbeatTimer hartbeat,
            IObservable<AppendEntryResultMessage> reply,
            IObserver<AppendEntryMessage> append,
            IObserver<ClientResultMessage> clientReply,
            IObservable<ClientMessage> client,
            ILogReplication logReplication, 
            Nodes nodes,
            ILoggerFactory loggerFactory,
            RaftOptions options, 
            ServerIdentifier serverIdentifier)
        {
            _isDispose = false;
            _hartbeat = hartbeat;
            _append = append;
            _clientReply = clientReply;
            _client = client;
            _logReplication = logReplication;
            _nodes = nodes;
            _options = options;
            _serverIdentifier = serverIdentifier;
            _election = election;
            _logger = loggerFactory.CreateLogger(nameof(Leader) + " " + serverIdentifier);

            if (_options.UseLogging)
                _logger.LogInformation($"{nameof(ServerStateType.Leader)}");

            // Reinitialized after election
            NextIndex = new ConcurrentDictionary<ServerIdentifier, int>();
            MatchIndex = new ConcurrentDictionary<ServerIdentifier, int>();
            _hartbeat.Leader(SendHartbeat);
            _replyDispose = reply.Subscribe(EntryReplyMessageRecived);
            _clientReplyDispose = client.Subscribe(ClientMessageRecived);
        }

        protected override Tags.Base ResolveSpecific(Nodes.Base node)
        {
            if (node is Nodes.Mapping)
                return new Tags.Mapping();
            if (node is Nodes.Sequence)
                return new Tags.Sequence();

            // overkill
            var scalarNode = (Nodes.Scalar)node;

            var value = scalarNode.Content;

            if (nullExpression.IsMatch(value))
                return new Tags.Null();

            if (boolExpression.IsMatch(value))
                return new Tags.Boolean();

            if (intExpression.IsMatch(value))
                return new Tags.Integer();

            if (floatExpression.IsMatch(value))
                return new Tags.FloatingPoint();

            return new Tags.String();
        }

 protected Attachment(Nodes.Node node, string label, string description)
 {
     _node = node;
     _label = label;
     _baselabel = label;
     _description = description;
 }

        /// <summary>
        /// Creates a new file manager.
        /// </summary>
        /// <param name="filename">The filename we want to load from or save to.</param>
        /// <param name="node">The behaviour we want to save. For loading use null.</param>
        public FileManager(string filename, Nodes.BehaviorNode node)
        {
            Debug.Check( Path.IsPathRooted(filename) );

            _filename = filename;
            _behavior = node;
        }

 private object ConstructDocument(Nodes.Base node)
 {
     var data = this.ConstructObject(node);
     this.constructedObjects.Clear();
     this.recursiveObjects.Clear();
     return data;
 }

        public Candidate(ServerIdentifier serverIdentifier, 
            IElectionTimer electionTimer,
            IObserver<RequestVoteMessage> requestVote,
            IObservable<RequestVoteResultMessage> voteReply, 
            IVotingSystem votingSystem,
            IElection election,
            ILogReplication logReplication,
            Nodes nodes,
            ILoggerFactory loggerFactory,            
            RaftOptions options)
        {
            isDispose = false;
            _electionTimer = electionTimer;
            _requestVote = requestVote;
            _voteReply = voteReply;
            _votingSystem = votingSystem;
            _serverIdentifier = serverIdentifier;        
            _election = election;
            _options = options;
            _logger = loggerFactory.CreateLogger(nameof(Candidate) + " " + serverIdentifier);
            _election.CurrentTerm++;
            _election.VotedFor = _serverIdentifier.Id;
            _logReplication = logReplication;
            _nodes = nodes;

            if (_options.UseLogging)
                _logger.LogInformation($"{nameof(ServerStateType.Candidate)}");

            RequestElection();
        }

 protected override Tags.Base ResolveSpecific(Nodes.Base node)
 {
     return this
            .Tags
            .Reverse()
            .Where(t => t.Validate(node))
            .First();
 }

 public static Rectangle getPaddedRect(Nodes.Node n) {
     Rectangle r = getRect(n);
     r.X -= ballSize / 2;
     r.Y -= ballSize / 2;
     r.Width += ballSize;
     r.Height += ballSize;
     return r;
 }

        /// <summary>
        /// Returns whether a behaviour was checked to be saved or not.
        /// </summary>
        /// <param name="node">The behaviour you want to check.</param>
        /// <returns>Returns true if the user wants the behaviour to be saved.</returns>
        internal bool IsSelected(Nodes.BehaviorNode node) {
            foreach(object obj in behaviorListBox.CheckedItems) {
                if (node == obj) {
                    return true;
                }
            }

            return false;
        }