private ConnectionItemData[] ConvertConnectionItems(Connection connection)
{
GraphicConnection graphicConnection = connection.LinkedObject as GraphicConnection;
List <ConnectionItemData> itemdatalist = new List <ConnectionItemData>(graphicConnection.Children.Count);
foreach (IConnectionItem item in graphicConnection.Children)
{
if (item is ConnectionLine)
{
ConnectionLine line = item as ConnectionLine;
LineItemData linedata = new LineItemData(line.Nodes[0].Name, line.Nodes[1].Name);
itemdatalist.Add(linedata);
}
if (item is ConnectionNode)
{
ConnectionNode node = item as ConnectionNode;
//if (node.Parent is GraphicTerminal) //impossible
//{
// NodeItemData nodedata = new NodeItemData(node.Name);
// nodedata.IsTerminalNode = true; //not needed
// itemdatalist.Add(nodedata);
//} else
if (node.Parent is GraphicConnection)
{
NodeItemData nodedata = new NodeItemData(node.Name);
//nodedata.IsTerminalNode = false; //not needed
nodedata.X = node.Location.X;
nodedata.Y = node.Location.Y;
itemdatalist.Add(nodedata);
}
}
}
return(itemdatalist.ToArray());
}
/// <summary>
/// Shows the connection context menu.
/// </summary>
/// <param name="connectionNode"></param>
private void ShowConnectionContextMenu(ConnectionNode connectionNode)
{
var genericMenu = new GenericMenu();
genericMenu.AddItem(new GUIContent("Delete connection"), false, () => DeleteConnectionNode(connectionNode));
genericMenu.ShowAsContext();
}
public override void OnReceived(Node node, ConnectionNode connectionNode)
{
var engine = node.Engine;
var recentValidHash = UInt256.Zero;
for (int i = 0; i < this.BlockLocators.Length; i++)
{
var hash = this.BlockLocators[i];
if (engine.BlockChain.BlockHeadDictionary.TryGetValue(hash, out var block))
{
recentValidHash = block.Hash;
break;
}
}
var items = engine.BlockChain.GetBlockHeaders(recentValidHash)
.Take(MaxBlockRetrivalNumber)
.Select(_ => new InventoryEntity(InventoryType.Block, _.Hash))
.ToArray();
var responseCmd = new InventoryCommand {
Items = items
};
connectionNode.Peer.Send(responseCmd);
}
protected override void DrawFields()
{
ConnectionNode node = target as ConnectionNode;
base.DrawFields();
NetworkNodeLock lockComp = node.GetComponent <NetworkNodeLock>();
if (lockComp != null)
{
GUI.enabled = false;
}
if (GUILayout.Button("Add lock"))
{
lockComp = node.gameObject.AddComponent <NetworkNodeLock>();
GameObject lockGroup = Instantiate(
AssetDatabase.LoadAssetAtPath <GameObject>("Assets/Prefabs/LockSpriteGroup.prefab"),
node.transform);
// lockGroup.transform.SetParent(node.transform);
SpriteRenderer[] sprites = lockGroup.GetComponentsInChildren <SpriteRenderer>();
for (int i = 0; i < NetworkNode.NeighborNum; i++)
{
lockComp.InputLockSprites[i] = sprites[i];
}
if (sprites.Length > NetworkNode.NeighborNum)
{
lockComp.LockBackgroundSprite = sprites[sprites.Length - 1];
}
}
GUI.enabled = true;
}
public override void OnReceived(Node node, ConnectionNode connectionNode)
{
var engine = node.Engine;
var bc = engine.BlockChain;
bc.SyncTx(this.Transaction);
}
internal void UpdateConn(ConnectionNode conn)
{
this.Connection = conn;
this.txtConnectionString.Text = conn.ConncetionString;
this.txtName.Text = conn.Name;
this.cmbDbType.SelectedValue = conn.DbType.ToString();
}
/// <summary>
/// Deletes a given connection node.
/// </summary>
/// <param name="connectionNode"></param>
private void DeleteConnectionNode(ConnectionNode connectionNode)
{
LevelGraph.Connections.Remove(connectionNode.Connection);
DestroyImmediate(connectionNode.Connection, true);
connectionNodes.Remove(connectionNode);
EditorUtility.SetDirty(LevelGraph);
}
protected ConnectionNode CreateConnection(Connection data, RoomNode from, RoomNode to)
{
var node = new ConnectionNode(data, from, to, connectionHandleStyle, connectionHandleStyleActive, 12);
node.OnDelete += () => OnDeleteConnectionNode(node);
connectionNodes.Add(node);
return(node);
}
/// <summary>
/// 连接字符串构造
/// </summary>
private void ConnectionStringFill()
{
ConnectionNode node = comboBoxEdit1.SelectedItem as ConnectionNode;
string DataSource = this.textEditDataSource.Text;
string Database = this.textEditDatabase.Text;
string UserId = this.textEditUserId.Text;
string Password = this.textEditPassword.Text;
this.richTextBoxConnectionString.Text = string.Format(node.connectionString, DataSource, Database, UserId, Password);
}
// Builds a graph over all connections going out of a group (the parent counts as one).
// While building the map, the existing routing of effectSlotUnderTest are ignored and pretended it is connected to targetToTest instead.
// Then checks are performed whether this setup would cause any loops in the graph.
static Dictionary <object, ConnectionNode> BuildTemporaryGraph(
List <AudioMixerGroupController> allGroups,
AudioMixerGroupController groupWhoseEffectIsChanged, AudioMixerEffectController effectWhoseTargetIsChanged, AudioMixerEffectController targetToTest,
AudioMixerGroupController modifiedGroup1, List <AudioMixerEffectController> modifiedGroupEffects1,
AudioMixerGroupController modifiedGroup2, List <AudioMixerEffectController> modifiedGroupEffects2
)
{
// First build the chains of groups and their contained effects
var graph = new Dictionary <object, ConnectionNode>();
foreach (var group in allGroups)
{
var groupNode = new ConnectionNode();
groupNode.group = group;
groupNode.effect = null;
graph[group] = groupNode;
object groupTail = group;
var reorderedEffects = (group == modifiedGroup1) ? modifiedGroupEffects1 : (group == modifiedGroup2) ? modifiedGroupEffects2 : group.effects.ToList();
foreach (var effect in reorderedEffects)
{
if (!graph.ContainsKey(effect))
{
graph[effect] = new ConnectionNode();
}
graph[effect].group = group;
graph[effect].effect = effect;
if (!graph[groupTail].targets.Contains(effect))
{
graph[groupTail].targets.Add(effect);
}
AudioMixerEffectController target = (group == groupWhoseEffectIsChanged && effectWhoseTargetIsChanged == effect) ? targetToTest : effect.sendTarget;
if (target != null)
{
if (!graph.ContainsKey(target))
{
graph[target] = new ConnectionNode();
graph[target].group = group;
graph[target].effect = target;
}
if (!graph[effect].targets.Contains(target))
{
graph[effect].targets.Add(target);
}
}
groupTail = effect;
}
graph[group].groupTail = groupTail;
}
return(graph);
}
public override void OnReceived(Node node, ConnectionNode connectionNode)
{
var engine = node.Engine;
var bc = engine.BlockChain;
var responseCmd = new GetDataCommand {
Items = this.Items
};
connectionNode.Peer.Send(responseCmd);
}
/// <summary>
/// Create a connection node from a given connection.
/// </summary>
/// <param name="connection"></param>
/// <returns></returns>
public ConnectionNode CreateConnectionNode(ConnectionBase connection)
{
var from = roomNodes.Single(x => x.Room == connection.From);
var to = roomNodes.Single(x => x.Room == connection.To);
var connectionNode = new ConnectionNode(connection, from, to);
connectionNodes.Add(connectionNode);
return(connectionNode);
}
void DrawFacingLine(ConnectionNode node, LineRenderer line, Transform mac)
{
line.startWidth = 0.2f;
line.endWidth = 0;
line.positionCount = 2;
line.SetPosition(0, node.Position);
line.SetPosition(1, node.Position + node.Facing);
mac.localPosition = node.Position;
mac.rotation = Quaternion.LookRotation(node.Facing, Vector3.up);
}
private async Task BuildViewAsync(ConnectionNode connectionNode)
{
connectionNode.Nodes.Clear();
try
{
pbMain.Visible = true;
await _scriptManager.GenerateScriptAsync(connectionNode.ConnectionName, new Progress <MergeProgress>(ShowProgress));
if (!_scriptManager.Actions.Any())
{
btnExecute.Enabled = false;
tbScript.Text = $"{_scriptManager.Syntax.CommentPrefix} Nothing to execute -- no model differences were found.";
return;
}
tbScript.Text = _scriptManager.Script.ToString();
foreach (var actionTypeGrp in _scriptManager.Actions.GroupBy(item => item.ActionType))
{
ActionTypeNode actionTypeNode = new ActionTypeNode(actionTypeGrp.Key, actionTypeGrp.Count());
connectionNode.Nodes.Add(actionTypeNode);
foreach (var objectTypeGrp in actionTypeGrp.GroupBy(item => item.ObjectType))
{
ObjectTypeNode objectTypeNode = new ObjectTypeNode(objectTypeGrp.Key, objectTypeGrp.Count());
actionTypeNode.Nodes.Add(objectTypeNode);
foreach (var action in objectTypeGrp)
{
ActionNode ndAction = new ActionNode(action);
ndAction.StartLine = _scriptManager.LineRanges[action].Start;
ndAction.EndLine = _scriptManager.LineRanges[action].End;
ndAction.ValidationErrors = _scriptManager.ValidationErrors[action].ToArray();
objectTypeNode.Nodes.Add(ndAction);
}
}
}
connectionNode.Checked = true;
connectionNode.ExpandAll();
}
finally
{
pbMain.Visible = false;
string status = "Ready";
if (_scriptManager.Stopwatch != null)
{
status += $", ran in {_scriptManager.Stopwatch.ElapsedMilliseconds:n0}ms";
}
tslStatus.Text = status;
}
}
private void btnOK_Click(object sender, EventArgs e)
{
if (this.Connection == null)
{
this.Connection = new ConnectionNode();
}
this.Connection.Name = this.txtName.Text.Trim();
this.Connection.ConncetionString = this.txtConnectionString.Text.Trim();
this.Connection.DbType = ((KeyValuePair <DatabaseType, string>) this.cmbDbType.SelectedItem).Key;
this.DialogResult = System.Windows.Forms.DialogResult.OK;
this.Close();
}
void MakeCurvesSimple
(ConnectionNode startNode, ConnectionNode endNode,
out ConnectionCurve startCurve, out ConnectionCurve endCurve)
{
Vector3 nodeDiff = endNode.Position - startNode.Position;
float ndLenght2 = nodeDiff.sqrMagnitude;
Vector3 startCentre = FindBestCentre(startNode, endNode.Position, ndLenght2);
Vector3 endCentre = FindBestCentre(endNode, startNode.Position, ndLenght2);
startCurve = new ConnectionCurve(startCentre, (startNode.Position - startCentre).NoY().normalized, startNode.Facing);
endCurve = new ConnectionCurve(endCentre, (endNode.Position - endCentre).NoY().normalized, endNode.Facing);
}
void MakeCurves(ConnectionNode startNode, ConnectionNode endNode,
out ConnectionCurve startCurve, out ConnectionCurve endCurve)
{
Vector3 nodeDiff = endNode.Position - startNode.Position;
float ndLenght2 = nodeDiff.sqrMagnitude;
float startToEndDirL2 = ((endNode.Position + endNode.Facing) - startNode.Position).sqrMagnitude;
float endToStartDirL2 = ((startNode.Position + startNode.Facing) - endNode.Position).sqrMagnitude;
Vector3 startCentre = FindBestCentre(startNode, (endNode.Position + endNode.Facing), startToEndDirL2);
Vector3 endCentre = FindBestCentre(endNode, (startNode.Position + startNode.Facing), endToStartDirL2);
startCurve = new ConnectionCurve(startCentre, (startNode.Position - startCentre).NoY().normalized, startNode.Facing);
endCurve = new ConnectionCurve(endCentre, (endNode.Position - endCentre).NoY().normalized, endNode.Facing);
}
private void AttemptConnection(ConnectionNode connectionNode)
{
connectionNode.ImageIndex = 5;
var rememberText = connectionNode.Text;
connectionNode.Text = connectionNode.Text + (connectionNode.HasConnected ? " (Refreshing...)" : " (Loading...)");
connectionNode.ForeColor = SystemColors.GrayText;
tvConnections.SelectedNode = null;
var bgWorker = new BackgroundWorker();
bgWorker.DoWork += WorkerAttemptConnection;
bgWorker.RunWorkerAsync(new { connectionNode, rememberText });
}
/// <summary>
/// Splits the connection line at the given point and places a node there
/// </summary>
/// <param name="line">the line to split</param>
/// <param name="atPoint">the point to place a node</param>
/// <returns>the placed node</returns>
private ConnectionNode SplitConnectionLine(ConnectionLine line, PointF atPoint)
{
GraphicConnection connection = line.Parent as GraphicConnection;
ConnectionNode node = new ConnectionNode(line.NearestPointOnLine(m_Editor.AlignToGrid(atPoint)));
ConnectionLine line1 = new ConnectionLine(line.Nodes[0], node);
ConnectionLine line2 = new ConnectionLine(line.Nodes[1], node);
connection.RemoveChild(line);
connection.AddChild(node);
connection.AddChild(line1);
connection.AddChild(line2);
return(node);
}
private async void btnRefresh_Click(object sender, EventArgs e)
{
try
{
ConnectionNode cnNode = tvwActions.SelectedNode?.FindParentNode <ConnectionNode>();
if (cnNode != null)
{
await BuildViewAsync(cnNode);
}
}
catch (Exception exc)
{
MessageBox.Show(exc.Message);
}
}
Vector3 FindBestCentre(ConnectionNode node, Vector3 otherPos, float sqrDist)
{
Vector3 perp = node.Facing.FlatPerpendicular();
Vector3 centre = node.Position + perp;
float dist1 = (otherPos - centre).sqrMagnitude;
float dist2 = (otherPos - (node.Position - perp)).sqrMagnitude;
Debug.Log($"1: {dist1}, 2: {dist2}");
if (dist1 > sqrDist && dist1 > dist2)
{
perp *= -1;
centre = node.Position + perp;
}
return(centre);
}
private void CreateConnectionLines(Circuit circuit, GraphicConnection graphicConnection, ConnectionData connectionData)
{
if (connectionData.Items == null || connectionData.Items.Length == 0)
{
//downward compatibility - no detailed information available:
Connection connection = graphicConnection.LinkedObject as Connection;
GraphicTerminal previous = null;
//displays straight lines from one terminal to another
foreach (Terminal terminal in connection.Terminals)
{
GraphicTerminal graphicTerminal = terminal.LinkedObject as GraphicTerminal;
if (previous != null)
{
graphicConnection.AddChild(new ConnectionLine(previous.ConnectionNode, graphicTerminal.ConnectionNode));
}
previous = graphicTerminal;
}
return;
}
//create nodes
foreach (ConnectionItemData itemData in connectionData.Items)
{
if (itemData is NodeItemData)
{
NodeItemData nodeData = itemData as NodeItemData;
ConnectionNode node = new ConnectionNode(nodeData.X, nodeData.Y);
graphicConnection.AddChild(node);
}
}
//create lines
foreach (ConnectionItemData itemData in connectionData.Items)
{
if (itemData is LineItemData)
{
LineItemData lineData = itemData as LineItemData;
ConnectionNode node1 = SearchNode(lineData.Node1, circuit, graphicConnection);
ConnectionNode node2 = SearchNode(lineData.Node2, circuit, graphicConnection);
if (node1 != null && node2 != null)
{
ConnectionLine line = new ConnectionLine(node1, node2);
graphicConnection.AddChild(line);
}
}
}
}
//
// Nodes
//
private ConnectionNode GetOrAddNode(T item)
{
ConnectionNode node;
if (!_nodesByItem.TryGetValue(item, out node))
{
_addContext.Add(item);
node = new ConnectionNode(item, GetOrAddDependencies(item), _cancellationToken);
_nodesByItem[item] = node;
_addContext.Remove(item);
}
return(node);
}
/// <summary>
/// 打开数据库连接
/// </summary>
/// <returns></returns>
private ConnectionState TryGetConnectState()
{
try
{
string connectionString = this.richTextBoxConnectionString.Text;
string database = this.textEditDatabase.Text;
ConnectionNode node = comboBoxEdit1.SelectedItem as ConnectionNode;
DbFactory.Instance().SetProperties(node.ProviderName, connectionString, database);
IDbConnection conn = DbFactory.Instance().CreateDbConnection();
conn.Open();
return(conn.State);
}
catch (Exception ex)
{
XtraMessageBox.Show(@"连接失败！" + ex.Message, @"警告", MessageBoxButtons.OK, MessageBoxIcon.Warning);
}
return(ConnectionState.Closed);
}
private async Task SelectAssemblyInner(string fileName)
{
tbAssembly.Text = fileName;
_scriptManager = ScriptManager.FromFile(fileName);
tvwActions.Nodes.Clear();
this.Text = $"Postulate Schema Merge - {_scriptManager.CurrentSyntax.ToString()}";
foreach (string name in _scriptManager.ConnectionNames)
{
ConnectionNode cnNode = new ConnectionNode(name);
tvwActions.Nodes.Add(cnNode);
await BuildViewAsync(cnNode);
}
if (_scriptManager.ConnectionErrors != null)
{
tbScript.Text = "/*\r\n" + _scriptManager.ConnectionErrors.ToString() + "*/";
}
}
public ConnectionScenario(ConnectionNode sNode, ConnectionNode eNode,
ConnectionCurve sCurve, ConnectionCurve eCurve)
{
StartCurve = sCurve;
EndCurve = eCurve;
StartNode = sNode;
EndNode = eNode;
if (sCurve.RotationDirection == eCurve.RotationDirection)
{
Type = eScenarioType.crossed;
}
else
{
Type = eScenarioType.perpendicular;
}
EvaluateScenario();
}
/// <summary>
/// Connect to a Connection
/// </summary>
/// <param name="connection"></param>
private void TryConnectToConnection(GraphicConnection connection, PointF location)
{
if (m_FromElement is GraphicTerminal)
{
Terminal fromTerminal = m_FromElement.LinkedObject as Terminal;
if (fromTerminal.Connection != null)
{
MergeConnections(fromTerminal.Connection.LinkedObject as GraphicConnection, m_LastMouseLocation, connection, location);
}
else
{
IConnectionItem connectionItem = connection.GetItemAt(location);
if (connectionItem is ConnectionNode)
{
//user clicked near a node - connect to this
ConnectionLine line = new ConnectionLine((m_FromElement as GraphicTerminal).ConnectionNode, connectionItem as ConnectionNode);
connection.AddChild(line);
}
else if (connectionItem is ConnectionLine)
{
//user clicked near a line
ConnectionLine prevLine = connectionItem as ConnectionLine;
//place a connection node at location - split connection line
ConnectionNode node = SplitConnectionLine(prevLine, location);
ConnectionLine line = new ConnectionLine(node, (m_FromElement as GraphicTerminal).ConnectionNode);
connection.AddChild(line);
}
connection.ConnectTerminal(m_FromElement as GraphicTerminal);
m_Editor.UpdateDrawing();
m_Editor.RaiseChangedEvent();
}
}
else if (m_FromElement is GraphicConnection)
{
MergeConnections(m_FromElement as GraphicConnection, m_LastMouseLocation, connection, location);
}
else if (m_FromElement is ConnectionNode)
{
MergeConnections(m_FromElement.Parent as GraphicConnection, m_LastMouseLocation, connection, location);
//GraphicConnection fromConnection = m_FromElement.Parent as GraphicConnection;
}
m_FromElement = null;
m_Editor.Invalidate();
}
private void addRoomSepLineFromBoundary(Room room, IList <ConnectionNode> nodes, SpatialElementBoundaryOptions options)
{
IList <IList <Autodesk.Revit.DB.BoundarySegment> > outline = room.GetBoundarySegments(options);
foreach (IList <Autodesk.Revit.DB.BoundarySegment> segments in outline)
{
foreach (Autodesk.Revit.DB.BoundarySegment segment in segments)
{
Element segElem = _doc.GetElement(segment.ElementId);
if (segElem is ModelCurve)
{
ElementId otherRoomId = ElementId.InvalidElementId;
XYZ location = segment.GetCurve().Evaluate(0.5, true);
Room r2 = getOtherRoom(room, segment, location);
if (r2 != null)
{
otherRoomId = r2.Id;
}
// see if it already exists.
var existing = nodes.FirstOrDefault(n => n.NodeType == Node.NodeTypeEnum.RoomBoundary && (n.Location.DistanceTo(location) < 0.01));
if (existing == null)
{
// we have a connection between rooms
ConnectionNode node = new ConnectionNode()
{
ConnectionType = ConnectionNode.ConnectionTypeEnum.RoomBoundary,
NodeType = Node.NodeTypeEnum.RoomBoundary,
LevelId = room.LevelId,
RoomId = room.Id,
Room2 = otherRoomId,
RevitId = segment.ElementId,
Location = segment.GetCurve().Evaluate(0.5, true)
};
nodes.Add(node);
}
}
}
}
}
/// <summary>
/// Used to add or update an existing connection.
/// </summary>
/// <param name="connectionId">The internal connection identifier.</param>
/// <param name="externalConnection">The external connection identifier.</param>
public void Add(Guid connectionId, TExternalConnection externalConnection, Guid userId)
{
if (this.lastCleaned.Elapsed() > this.cleanAfterMs)
{
this.Clean();
this.lastCleaned.Reset();
}
ConnectionNode node;
if (!this.connectionIdToExternal.ContainsKey(connectionId))
{
node = new ConnectionNode(
connectionId,
externalConnection,
userId);
if (this.connectionIdToExternal.TryAdd(connectionId, node))
{
this.externalToConnectionId[externalConnection] = node;
}
}
}
private void RemoveConnections(ConnectionNode node)
{
if (connections != null)
{
List <Connection> connectionsToRemove = new List <Connection>();
for (int i = 0; i < connections.Count; i++)
{
if (node.ContainsConnection(connections[i].inPoint) || node.ContainsConnection(connections[i].outPoint))
{
connectionsToRemove.Add(connections[i]);
}
}
for (int i = 0; i < connectionsToRemove.Count; i++)
{
connections.Remove(connectionsToRemove[i]);
}
connectionsToRemove = null;
}
}
/**---------------------------------------------------------------------------------
* Gets a random rotation of the specified tile.
*/
private float getRandomRotation(ConnectionNode connection, System.Random rand)
{
float randomNumber = (float)rand.NextDouble() * 100.0f;
RotationChanceNode rotation = null;
float chance = 0.0f;
for (int i = 0; i < connection.Rotations.Count; i++)
{
rotation = connection.Rotations[i];
if (randomNumber >= chance && randomNumber <= connection.Chance + chance)
break;
chance += rotation.Chance;
}
return rotation.Rotation;
}