/// <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);
}
/// <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);
}
/// <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);
}