Пример #1
0
        /// <summary>
        /// Encode a block subtree as XML with XY coordinates.
        /// </summary>
        /// <param name="block"> The root block to encode.</param>
        /// <param name="optNoId"> True if the encoder should skip the block id.</param>
        /// <returns> Tree of xml elements</returns>
        public static XmlNode BlockToDomWithXY(Block block, bool optNoId)
        {
            int width   = 0; // Not used in LTR.
            var element = Xml.BlockToDom(block, optNoId);
            var xy      = block.XY;

            element.SetAttribute("x", Mathf.Round(block.Workspace.RTL ? width - xy.x : xy.x).ToString());
            element.SetAttribute("y", Mathf.Round(xy.y).ToString());
            return(element);
        }
Пример #2
0
        /// <summary>
        /// Encode a block subtree as XML.
        /// </summary>
        /// <param name="block">The root block to encode.</param>
        /// <param name="optNoId">True if the encoder should skip the block id.</param>
        /// <returns></returns>
        public static XmlNode BlockToDom(Block block, bool optNoId = false)
        {
            var element = XmlUtil.CreateDom(block.IsShadow ? "shadow" : "block");

            element.SetAttribute("type", block.Type);
            if (!optNoId)
            {
                element.SetAttribute("id", block.ID);
            }

            if (block.Mutator != null)
            {
                // Custom data for an advanced block.
                var container = block.Mutator.ToXml();
                if (container != null)
                {
                    element.AppendChild(container);
                }
            }

            Action <Field> fieldToDom = delegate(Field field)
            {
//                if  TODO: editable is true (!string.IsNullOrEmpty(field.Name) && field.Editable)
                if (!string.IsNullOrEmpty(field.Name))
                {
                    var container = XmlUtil.CreateDom("field", null, field.GetValue());
                    container.SetAttribute("name", field.Name);
                    if (field is FieldVariable)
                    {
                        var variable = block.Workspace.GetVariable(field.GetValue());
                        if (null != variable)
                        {
                            container.SetAttribute("id", variable.ID);
                            container.SetAttribute("variableType", variable.Type);
                        }
                    }
                    element.AppendChild(container);
                }
            };

            foreach (var input in block.InputList)
            {
                foreach (var field in input.FieldRow)
                {
                    fieldToDom(field);
                }
            }

            if (!string.IsNullOrEmpty(block.Data))
            {
                var dataElement = XmlUtil.CreateDom("data", null, block.Data);
                element.AppendChild(dataElement);
            }

            foreach (var input in block.InputList)
            {
                XmlNode container = null;
                var     empty     = true;
                if (input.Type == Define.EConnection.DummyInput)
                {
                    continue;
                }
                else
                {
                    var childBlock = input.Connection.TargetBlock;
                    if (input.Type == Define.EConnection.InputValue)
                    {
                        container = XmlUtil.CreateDom("value");
                    }
                    else if (input.Type == Define.EConnection.NextStatement)
                    {
                        container = XmlUtil.CreateDom("statement");
                    }

                    var shadow = input.Connection.ShadowDom;

                    if (null != shadow && (null == childBlock || !childBlock.IsShadow))
                    {
                        //        container.appendChild(Blockly.Xml.cloneShadow_(shadow));
                    }
                    if (null != childBlock)
                    {
                        container.AppendChild(Xml.BlockToDom(childBlock, optNoId));
                        empty = false;
                    }
                }
                container.SetAttribute("name", input.Name);

                if (!empty)
                {
                    element.AppendChild(container);
                }
            }

            if (block.Collapsed)
            {
                element.SetAttribute("collapsed", "true");
            }
            if (block.Disabled)
            {
                element.SetAttribute("disabled", "true");
            }
            if (!block.Deletable && !block.IsShadow)
            {
                element.SetAttribute("deletable", "false");
            }
            if (!block.Movable && !block.IsShadow)
            {
                element.SetAttribute("movable", "false");
            }
            if (!block.Editable)
            {
                element.SetAttribute("editable", "false");
            }

            var nextBlock = block.NextBlock;

            if (null != nextBlock)
            {
                var container = XmlUtil.CreateDom("next", null, BlockToDom(nextBlock, optNoId));
                element.AppendChild(container);
            }

            return(element);
        }
Пример #3
0
        /// <summary>
        /// Connect two connections together.  This is the connection on the superior block.
        /// </summary>
        /// <param name="childConnection"></param>
        private void ConnectInternal(Connection childConnection)
        {
            var parentConnection = this;
            var parentBlock      = parentConnection.SourceBlock;
            var childBlock       = childConnection.SourceBlock;

            // Disconnect any existing parent on the child connection.
            if (childConnection.IsConnected)
            {
                childConnection.Disconnect();
            }

            // Other connection is already connected to something.
            // Disconnect it and reattach it or bump it as needed.
            if (parentConnection.IsConnected)
            {
                Block   orphanBlock = parentConnection.TargetBlock;
                XmlNode shadowDom   = parentConnection.ShadowDom;
                parentConnection.ShadowDom = null;

                if (orphanBlock.IsShadow)
                {
                    // Save the shadow block so that field values are preserved.
                    shadowDom = Xml.BlockToDom(orphanBlock);
                    orphanBlock.Dispose();
                    orphanBlock = null;
                }
                else if (parentConnection.Type == Define.EConnection.InputValue)
                {
                    //value connnections
                    if (orphanBlock.OutputConnection == null)
                    {
                        throw new Exception("Orphan block does not have an output connection.");
                    }

                    // Attempt to reattach the orphan at the end of the newly inserted
                    // block.  Since this block may be a row, walk down to the end
                    // or to the first (and only) shadow block.
                    var connection = Connection.LastConnectionInRow(childBlock, orphanBlock);
                    if (connection != null)
                    {
                        orphanBlock.OutputConnection.Connect(connection);
                        orphanBlock = null;
                    }
                }
                else if (parentConnection.Type == Define.EConnection.NextStatement)
                {
                    // Statement connections.
                    // Statement blocks may be inserted into the middle of a stack.
                    // Split the stack.
                    if (orphanBlock.PreviousConnection == null)
                    {
                        throw new Exception("Orphan block does not have a previous connection.");
                    }

                    // Attempt to reattach the orphan at the bottom of the newly inserted
                    // block.  Since this block may be a stack, walk down to the end.
                    var newBlock = childBlock;
                    while (newBlock.NextConnection != null)
                    {
                        var nextBlock = newBlock.NextBlock;
                        if (nextBlock != null && !nextBlock.IsShadow)
                        {
                            newBlock = nextBlock;
                        }
                        else
                        {
                            if (orphanBlock.PreviousConnection.CheckType(newBlock.NextConnection))
                            {
                                newBlock.NextConnection.Connect(orphanBlock.PreviousConnection);
                                orphanBlock = null;
                            }
                            break;
                        }
                    }
                }

                if (orphanBlock != null)
                {
                    // Unable to reattach orphan.
                    parentConnection.Disconnect();
                    Connection orphanBlockCon = orphanBlock.OutputConnection != null ? orphanBlock.OutputConnection : orphanBlock.PreviousConnection;
                    orphanBlockCon.FireUpdate(UpdateState.BumpedAway);
                }

                // Restore the shadow DOM.
                parentConnection.ShadowDom = shadowDom;
            }

            // Establish the connections.
            Connection.ConnectReciprocally(parentConnection, childConnection);
            // Demote the inferior block so that one is a child of the superior one.
            childBlock.SetParent(parentBlock);

            FireUpdate(UpdateState.Connected);
        }