public void Start(int port = 0)
{
_listenning = false;
_newConnections = new Queue <NewConnection>();
_clients = new Dictionary <int, ORTCPClient>();
if (port != 0)
{
StartListening(port);
}
else
{
StartListening();
}
Observable
.Interval(TimeSpan.FromSeconds(1))
.Where(_ => _newConnections.Count > 0)
.Subscribe(_ =>
{
//Debug.Log(Thread.CurrentThread.ManagedThreadId);
NewConnection newConnection = _newConnections.Dequeue();
ORTCPClient client = ORTCPClient.CreateInstance("ORMultiServerClient", newConnection.tcpClient, this, port);
int clientID = SaveClient(client);
ORTCPEventParams eventParams = new ORTCPEventParams();
eventParams.eventType = ORTCPEventType.Connected;
eventParams.client = client;
eventParams.clientID = clientID;
eventParams.socket = newConnection.tcpClient;
Console.BackgroundColor = ConsoleColor.Cyan;
Console.ForegroundColor = ConsoleColor.Black;
Console.WriteLine("[TCPServer] New client connected");
});
}
public async Task <CQConnection> ConnectTo(string hostport)
{
var parts = hostport.Split(new[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
var hostName = parts[0];
var portNumber = parts.Length > 1 ? int.Parse(parts[1]) : 18593;
var connection = await CQConnection.Create(_crypt, hostName, portNumber, _rsa, _onStatusChange);
ValidateWhitelistAndSetAlias(connection);
lock (_connections)
{
// NOTE: prior connections to same peer are not removed, by design
_connections.Add(connection);
}
try
{
NewConnection?.Invoke(this, new CQConnectionEventArgs
{
Connection = connection
});
}
catch (Exception ex)
{
ex.Log();
}
$"Connected to [{connection}]".Log();
return(connection);
}
private void miNewConnection_Click(object sender, RoutedEventArgs e)
{
// open new connection from
NewConnection nc = new NewConnection();
nc.ShowDialog();
}
void newConnection_Closing(object sender, System.ComponentModel.CancelEventArgs e)
{
NewConnection newConnection = (NewConnection)sender;
switch (newConnection.Status)
{
case Classes.WindowResult.Created:
this.Project.Connections.Add(newConnection.ConnectionConfiguration);
break;
case Classes.WindowResult.Canceled:
if (newConnection.ConnectionConfiguration == null || newConnection.OriginalConnectionConfiguration == null)
{
return;
}
object revertedConfiguration = ConfigurationSerializer.DeserializeObject(
newConnection.OriginalConnectionConfiguration,
newConnection.ConnectionConfiguration.GetType(),
moduleLoader.GetModuleTypeList()
);
((ConnectionConfigurationBase)revertedConfiguration).ModuleDescription = newConnection.ConnectionConfiguration.ModuleDescription;
int indexConfiguration = this.Project.Connections.IndexOf(newConnection.ConnectionConfiguration);
this.Project.Connections[indexConfiguration] = revertedConfiguration as ConnectionConfigurationBase;
break;
}
}
/*接收新的连接*/
private void OnAcceptNewConnection(object sender, SocketAsyncEventArgs e)
{
/*新连接的socket对象*/
var socket = e.AcceptSocket;
/*继续接收*/
startAccept(e);
/*连接数+1*/
Interlocked.Increment(ref connectionCount);
/*尝试取出一个异步完成套接字*/
if (!receiveAsyncEventQueue.TryDequeue(out var socketReceiveAsync))
{
socketReceiveAsync = new SocketAsyncEventArgs();
socketReceiveAsync.Completed += SocketAsync_Receive_Completed;
socketReceiveAsync.SetBuffer(new byte[bufferLength], 0, bufferLength);
}
/*创建一个客户端*/
var connection = new SocketClient
{
SocketAsyncEvent = socketReceiveAsync,
RemoteEndPoint = socket.RemoteEndPoint,
Socket = socket,
};
socketReceiveAsync.UserToken = connection;
NewConnection?.Invoke(this, connection);
StartReceive(connection);
}
virtual internal void OnNewConnection(INetworkNode Remote)
{
if (Remote == null)
{
return;
}
if (!Remotes.Contains(Remote))
{
Remotes.Add(Remote);
}
if (NewConnection == null)
{
return;
}
Task.Run(() =>
{
NewConnection?.Invoke(this, new InternetConnectionEventArgs
{
Local = this,
Remote = Remote
});
});
}
private void Start()
{
_listenning = false;
_newConnections = new Queue <NewConnection>();
_clients = new Dictionary <int, ORTCPClient>();
StartListening();
Observable
.EveryUpdate()
.Where(_ => _newConnections.Count > 0)
.Subscribe(_ =>
{
//Debug.Log(Thread.CurrentThread.ManagedThreadId);
NewConnection newConnection = _newConnections.Dequeue();
ORTCPClient client = ORTCPClient.CreateInstance("ORMultiServerClient", newConnection.tcpClient, this);
int clientID = SaveClient(client);
ORTCPEventParams eventParams = new ORTCPEventParams();
eventParams.eventType = ORTCPEventType.Connected;
eventParams.client = client;
eventParams.clientID = clientID;
eventParams.socket = newConnection.tcpClient;
if (verbose)
{
print("[TCPServer] New client connected");
}
});
}
async Task ConnectionWaitAsync()
{
_logger.LogInformation("Server: Waiting for connection");
if (_listener is null)
{
return;
}
var tcs = new TaskCompletionSource <int>();
await using (Token.Register(tcs.SetCanceled))
{
while (!Token.IsCancellationRequested)
{
var t = _listener.AcceptTcpClientAsync();
if ((await Task.WhenAny(t, tcs.Task)).IsCanceled)
{
break;
}
try
{
using var client = t.Result;
var message = await JsonSerializer.DeserializeAsync <Message>(client.GetStream());
var endPoint = client.Client.RemoteEndPoint;
await(NewConnection?.Invoke(endPoint as IPEndPoint, message.Type) ?? Task.CompletedTask);
await(MessageReceived?.Invoke(message, endPoint as IPEndPoint) ?? Task.CompletedTask);
}
catch (SocketException e)
{
_logger.LogError("Server: Error on ConnectionWaiting.", e);
}
}
}
_listener.Stop();
}
void Start()
{
isListening = false;
newConnections = new Queue <NewConnection>();
clients = new Dictionary <int, ORTCPClient>();
StartListening();
Observable
.Interval(TimeSpan.FromSeconds(1))
.Where(x => newConnections.Count > 0)
.Subscribe(x =>
{
NewConnection newConnection = newConnections.Dequeue();
ORTCPClient client = ORTCPClient.CreateClientInstance("MultiserverClient", newConnection.tcpClient, this);
int clientId = SaveClient(client);
TCPEventParams eventParams = new TCPEventParams();
eventParams.eventType = eTCPEventType.Connected;
eventParams.client = client;
eventParams.clientID = clientId;
eventParams.socket = newConnection.tcpClient;
if (verbose)
{
print("[TCPServer] New Client Connected: " + client.name);
}
});
}
public async Task ReceiveMessagesUntilCloseAsync()
{
try
{
NewConnection?.Invoke(this, EventArgs.Empty);
byte[] receivePayloadBuffer = new byte[_receivePayloadBufferSize];
WebSocketReceiveResult webSocketReceiveResult =
await _webSocket.ReceiveAsync(new ArraySegment <byte>(receivePayloadBuffer),
CancellationToken.None);
CloseStatus = await GetMessage(webSocketReceiveResult);
CloseStatusDescription = webSocketReceiveResult.CloseStatusDescription;
}
catch (WebSocketException webSocketException) when(webSocketException
.WebSocketErrorCode ==
WebSocketError.ConnectionClosedPrematurely)
{
Console.WriteLine(
"connection ConnectionClosedPrematurely (exception is catch-ed) ");
}
catch (OperationCanceledException)
{
// Happens when the application closes
Console.WriteLine("connection OperationCanceledException (exception is catch-ed)");
}
}
private void StartListenRequests()
{
_logger.Trace("Запуск прослушивания подключений...");
while (true)
{
try
{
var handler = _serverSocket.Accept();
var builder = new StringBuilder();
int bytes = 0;
byte[] data = new byte[256];
do
{
bytes = handler.Receive(data);
builder.Append(Encoding.Unicode.GetString(data, 0, bytes));
}while (handler.Available > 0);
_logger.Trace("Обнаружено новое подключение...");
var message = builder.ToString();
NewConnection?.Invoke(message, handler);
}
catch (Exception e)
{
_logger.Error($"Произошла ошибка при получении запроса: {e.Message}");
}
}
}
/// <summary>
/// Adds to the Inbound Requests que and adds to the connections list if a matching IP does not exist.
/// </summary>
/// <param name="from">IPAddress of the request</param>
private static void AddInboundRequest(object from)
{
IPAddress sender = (IPAddress)from;
bool found = false;
foreach (ConnectionInfo connection in connections)
{
if (connection.address.Equals(sender))
{
found = true;
if (!InboundReq.Contains(connection))
{
InboundReq.Add(connection);
connection.InvokeInboundRequest();
}
else if (OutboundReq.Contains(connection))
{
GameConnection.RequestGame(connection);
}
break;
}
}
if (found == false && NewConnection != null)
{
ConnectionInfo connection = new ConnectionInfo()
{
address = sender, displayName = "Unknown"
};
connections.Add(connection);
InboundReq.Add(connection);
NewConnection.Invoke(null, connection);
connection.InvokeInboundRequest();
}
}
public TCPService(int portNumber, int maxConnections, NewConnection newConnection, GetCount getCount)
{
PortNumber = portNumber;
MaxConnections = maxConnections;
AcceptedConnections = 0;
OnNewConnection = newConnection;
GetConnectCount = getCount;
}
public TCPService(int portNumber, int maxConnections, NewConnection newConnection, GetCount getCount)
{
PortNumber = portNumber;
MaxConnections = maxConnections;
AcceptedConnections = 0;
OnNewConnection = newConnection;
GetConnectCount = getCount;
}
protected override void OnStartup(StartupEventArgs e)
{
InDesignMode = false;
Current = (App)Application.Current;
Res = new AppResources();
EnsureUserFolders();
Task.Run(() => Firewall.Instance.GrantAuthorizationToSelf());
var firstArg = e.Args.FirstOrDefault();
if (firstArg?.Equals("-nonew", StringComparison.OrdinalIgnoreCase) == true)
{
new MainWindow().Show();
}
else if (firstArg?.Equals("-settings", StringComparison.OrdinalIgnoreCase) == true && e.Args.Length == 2)
{
var cs = ConnectionSettings.Deserialize(File.ReadAllBytes(e.Args[1]));
var session = cs.CreateSession();
if (session != null)
{
var mainWindow = new MainWindow();
mainWindow.Show();
mainWindow.AddSessionAndStart(session);
}
}
else
{
Rect rect = Rect.Empty;
var session = SessionFromArgs(e.Args);
if (session == null)
{
ShutdownMode = ShutdownMode.OnExplicitShutdown;
var dlg = new NewConnection()
{
ShowInTaskbar = true, Title = "Swiddler", WindowStartupLocation = WindowStartupLocation.CenterScreen
};
dlg.ShowDialog();
session = dlg.Result;
rect = new Rect(dlg.Left, dlg.Top, dlg.Width, dlg.Height);
}
if (session != null)
{
ShutdownMode = ShutdownMode.OnLastWindowClose;
var mainWindow = new MainWindow();
if (!rect.IsEmpty)
{
mainWindow.Left = (rect.Width - mainWindow.Width) / 2.0 + rect.Left; // center of closed NewConnection dialog
mainWindow.Top = (rect.Height - mainWindow.Height) / 2.0 + rect.Top;
}
mainWindow.Show();
mainWindow.AddSessionAndStart(session);
}
}
}
public static void FinishStreamWithUser(IAsyncResult resobj)
{
NewConnection CONNECTION = (NewConnection)resobj.AsyncState;
if (CONNECTION.Client.Connected)
{
CONNECTION.StopThreading();
}
}
private void HandshakeFinished(IAsyncResult status)
{
TrySocketAction(r =>
{
r.EndSend(status);
r.BeginReceive(ReceivedDataBuffer, 0, ReceivedDataBuffer.Length, 0, new AsyncCallback(Read), null);
NewConnection?.Invoke(this, EventArgs.Empty);
});
}
public Task NewConnectionAsync(Connection connection)
{
Workload();
if (NewConnection == null)
{
return(Task.CompletedTask);
}
return(NewConnection?.Invoke(connection));
}
public Task NewConnectionAsync(ObjectPath device, CloseSafeHandle fileDescriptor, IDictionary <string, object> properties)
{
SocketState = SocketStates.Connected;
_fileDescriptor = fileDescriptor;
Log.Debug("Linux.BluetoothSocket: Connected to profile");
Stream = new UnixStream(fileDescriptor.DangerousGetHandle().ToInt32());
Task.Run(() => NewConnection?.Invoke(device, _fileDescriptor, properties));
return(Task.CompletedTask);
}
private void lbConnections_MouseDoubleClick(object sender, MouseButtonEventArgs e)
{
ConnectionConfigurationBase connectionConfiguration = ((ListBox)sender).SelectedItem as ConnectionConfigurationBase;
if (connectionConfiguration != null)
{
string orginalConnectionConfiguration = ConfigurationSerializer.SerializeObject(connectionConfiguration, this.moduleLoader.GetModuleTypeList());
NewConnection newConnection = new NewConnection(this.moduleLoader.Modules, connectionConfiguration, orginalConnectionConfiguration);
ShowNewConnectionWindow(newConnection);
}
}
private void HandleConnectionPacket(TcpPacket tcpPacket, ConnectionId connectionId)
{
var connection = new TcpConnection(connectionId, tcpPacket.SequenceNumber);
NewConnection?.Invoke(connection);
if (connection.HasSubscribers)
{
_connections[connectionId] = connection;
}
}
private void HandleTcpDataReceived(TcpConnection connection, ArraySegment <byte> data)
{
if (data.Count == 0)
{
return;
}
if (_isNew.Contains(connection))
{
if (_serversByIp.ContainsKey(connection.Source.Address.ToString()) &&
data.Array.Skip(data.Offset).Take(4).SequenceEqual(new byte[] { 1, 0, 0, 0 }))
{
_isNew.Remove(connection);
var server = _serversByIp[connection.Source.Address.ToString()];
_serverToClient = connection;
_clientToServer = null;
_decrypter = new ConnectionDecrypter();
_decrypter.ClientToServerDecrypted += HandleClientToServerDecrypted;
_decrypter.ServerToClientDecrypted += HandleServerToClientDecrypted;
_messageSplitter = new MessageSplitter();
_messageSplitter.MessageReceived += HandleMessageReceived;
NewConnection?.Invoke(server);
}
if (_serverToClient != null && _clientToServer == null &&
(_serverToClient.Destination.Equals(connection.Source) &&
_serverToClient.Source.Equals(connection.Destination)))
{
_isNew.Remove(connection);
_clientToServer = connection;
}
}
if (!(connection == _clientToServer || connection == _serverToClient))
{
return;
}
if (_decrypter == null)
{
return;
}
var dataArray = data.Array.Skip(data.Offset).Take(data.Count).ToArray();
if (connection == _clientToServer)
{
_decrypter.ClientToServer(dataArray);
}
else
{
_decrypter.ServerToClient(dataArray);
}
}
virtual internal void OnNewConnection(INetworkNode Remote)
{
if (NewConnection != null)
{
Task.Run(() =>
{
NewConnection?.Invoke(this, new InternetConnectionEventArgs
{
Local = this,
Remote = Remote
});
});
}
}
private void AcceptConnectCallback(IAsyncResult ar)
{
Listener = (Socket)ar.AsyncState;
//acknowledge the connection
Socket incomingSocket = null;
try
{
incomingSocket = Listener.EndAccept(ar);
}
catch
{
ReportError?.Invoke("EndAccept failed on incoming connection", "");
}
//put the listener back to listening
Listener.BeginAccept(new AsyncCallback(AcceptConnectCallback), Listener);
if (incomingSocket == null)
{
return;
}
IPEndPoint ep = (IPEndPoint)incomingSocket.RemoteEndPoint;
TConnection C = new TConnection();
C.Setup(incomingSocket, ep.Address, ep.Port, ConnectionBufSize);
if (AllConnections.ContainsKey(C.Address) == false)
{
AllConnections.Add(C.Address, C);
AllConnectionsList.Add(C);
}
//Signal that a new connection has been created
NewConnection?.Invoke(C);
//configure the socket to receive incoming data and arm the data reception event
try
{
C.ConnectionSocket.BeginReceive(C.IncomingData, 0, C.IncomingData.Length, 0, new AsyncCallback(ReadCallback), C.Address);
}
catch
{
ReportError?.Invoke("BeginReceive failed on new connection", C.Address);
}
}
public void Update(GameTime time)
{
NetIncomingMessage im;
while ((im = Peer.ReadMessage()) != null)
{
switch (im.MessageType)
{
case NetIncomingMessageType.StatusChanged:
NetConnectionStatus status = (NetConnectionStatus)im.ReadByte();
string reason = im.ReadString();
if (!GameRunning && status == NetConnectionStatus.Connected)
{
Sync.AddConnection(im.SenderConnection);
NewConnection?.Invoke(this, im.SenderConnection);
}
break;
case NetIncomingMessageType.DiscoveryRequest:
// Respond to discovery requests with a json-serialized game info
// But only send the non-secret parts
var publicInfo = GameInfo.PublicInfo();
var serializedInfo = JsonConvert.SerializeObject(publicInfo);
var response = Peer.CreateMessage();
response.Write(serializedInfo);
Peer.SendDiscoveryResponse(response, im.SenderEndPoint);
break;
case NetIncomingMessageType.Data:
Sync.ReadMessage(im);
break;
}
Peer.Recycle(im);
}
if (GameRunning && WorldSyncTimer.ElapsedMilliseconds > Network.WorldSyncIntervalMs)
{
// Send full world state on every frame.
//Todo: Only send updates for world synchronization
SendWorldState();
WorldSyncTimer.Restart();
}
}
private void onConnectionBegin(InConnection inc, IAdapter outAdapter)
{
if (LoggingLevel <= Logging.Level.None)
{
debug($"'{inc.InAdapter.Name}' {inc} -> '{outAdapter.Name}'");
}
try {
lock (InConnectionsLock) {
inc.InAdapter.GetAdapter().CreatedConnections++;
_totalHandledConnections++;
InConnections.Add(inc.Id, inc);
NewConnection?.Invoke(inc);
}
} catch (Exception e) {
Logger.exception(e, Logging.Level.Error, "event NewConnection");
}
}
protected void AcceptHandler(IAsyncResult ar)
{
// Signal the main thread to continue.
_connAccepted.Set();
// Get the socket that handles the client request.
Socket clientSock = this._socket.EndAccept(ar);
_logger.Debug($"Client connected from {clientSock.RemoteEndPoint}");
// Create client
InputConnection client = new InputConnection(clientSock);
// Emit events and run default class handler
this.OnConnection(client);
NewConnection?.Invoke(client);
}
private void Awake()
{
if (_instance != null && _instance != this)
{
Destroy(this.gameObject);
}
else
{
_instance = this;
}
//debug binding
Observable.EveryUpdate()
.Select(_ => GameManager.TargetObject_External)
.DistinctUntilChanged()
.Subscribe(_ => verbose = (GameManager.TargetObject_External & TargetObject.TCP) == TargetObject.TCP)
.AddTo(gameObject);
_listenning = false;
_newConnections = new Queue <NewConnection>();
_clients = new Dictionary <int, ORTCPClient>();
StartListening();
Observable
.EveryUpdate()
.Where(_ => _newConnections.Count > 0)
.Subscribe(_ =>
{
//Debug.Log(Thread.CurrentThread.ManagedThreadId);
NewConnection newConnection = _newConnections.Dequeue();
ORTCPClient client = ORTCPClient.CreateInstance("ORMultiServerClient", newConnection.tcpClient, this);
int clientID = SaveClient(client);
ORTCPEventParams eventParams = new ORTCPEventParams();
eventParams.eventType = ORTCPEventType.Connected;
eventParams.client = client;
eventParams.clientID = clientID;
eventParams.socket = newConnection.tcpClient;
if (verbose)
{
print("[TCPServer] New client connected");
}
});
}
private void InitialiseSocketHandler(TcpClient socket)
{
var handler = new FtpSocketHandler(m_fileSystemClassFactory, m_nId);
handler.UserLoginEvent += UserLoginEvent;
handler.UserLogoutEvent += UserLogoutEvent;
// get encoding for the socket connection
handler.Start(socket, m_encoding);
m_apConnections.Add(handler);
numberOfConnections = m_apConnections.Count;
Trace.WriteLine($"Add a new handler, current connection number is {numberOfConnections}", "Information");
handler.Closed += Handler_Closed;
NewConnection?.Invoke(m_nId);
}
private void ShowConnectionDialog(UnicornConnection info = null)
{
var shouldUpdate = SelectedConnection != null;
info = info ?? new UnicornConnection();
var newConnection = new NewConnection(info);
if (newConnection.ShowModal() != true)
{
return;
}
LoadConnections();
if (shouldUpdate)
{
SelectedConnection = null;
SelectedConnection = info;
}
}
protected virtual ServerPlayer AcceptTCPConnection(TCPConnectionManager.PendingClient client)
{
ServerPlayer p = NewPlayerRecord(client);
Logger.Log3("Socket " + p.GetTCPRemoteAddresString() + " Connected ");
p.Disconnected += P_Disconnected;
p.PlayerID = FindPlayerID();
if (p.PlayerID < 0)
{
return(null);
}
lock (ConnectedPlayers)
ConnectedPlayers.Add(p.PlayerID, p);
NewConnection?.Invoke(this, p);
return(p);
}
///<summary>
/// Default constructor for FerdaView class.
///</summary>
///<param name="locManager">
/// Interface that takes care of the
///localizacion in the application
/// </param>
///<param name="svgMan">
/// Interface for providing SVG graphics
///</param>
///<param name="menuDisp">Menu displayer</param>
///<param name="view">The view thath should be connected to this desktop</param>
///<param name="pm">The project manager of the application</param>
///<param name="arch">Control that displays the archive</param>
///<param name="provider">Provider of the icons</param>
///<param name="toolBar">Toolbar control</param>
public FerdaDesktop(Menu.ILocalizationManager locManager,
SVGManager svgMan, IMenuDisplayer menuDisp, ProjectManager.View view,
ProjectManager.ProjectManager pm, Archive.IArchiveDisplayer arch,
IIconProvider provider, IMenuDisplayer toolBar)
: base()
{
//setting the icon
this.provider = provider;
//adding the localization
localizationManager = locManager;
ResManager = localizationManager.ResManager;
//adding the svgManager
svgManager = svgMan;
//setting the menu displayer
menuDisplayer = menuDisp;
archiveDisplayer = arch;
this.toolBar = toolBar;
//Current view
this.view = view;
projectManager = pm;
//name of the desktop
Name = view.Name;
//properties od the GraphControl to work propertly
AllowMoveShape = true;
AllowAddConnection = true;
AllowAddShape = true;
AllowDeleteShape = true;
AllowDrop = true;
AutoScroll = true;
EnableContextMenu = true;
EnableLayout = false;
ShowGrid = false;
Zoom = 1;
RestrictToCanvas = false;
this.ImeMode = System.Windows.Forms.ImeMode.On;
//for now trial stuff
BackgroundType = Netron.GraphLib.CanvasBackgroundTypes.Gradient;
GradientTop = System.Drawing.Color.SkyBlue;
//EventHandlers
GotFocus += new EventHandler(FerdaDesktop_GotFocus);
OnContextMenu += new MouseEventHandler(FerdaDesktop_ContextMenu);
OnNewConnection += new NewConnection(FerdaDesktop_OnNewConnection);
KeyPress += new KeyPressEventHandler(FerdaDesktop_KeyPress);
OnFerdaMouseUp += new MouseEventHandler(FerdaDesktop_OnFerdaMouseUp);
OnFerdaDeleteConnection += new FerdaConnection(FerdaDesktop_OnFerdaDeleteConnection);
OnShapeRemoved += new NewShape(FerdaDesktop_OnShapeRemoved);
//Setting the arrow for connections
DefaultLineEnd = ConnectionEnds.RightFilledArrow;
//Creation of the boxes and connections
Adapt();
}
/// <summary>
/// Reacts to a click for a module asking for creation and adds the module
/// to the view
/// </summary>
/// <param name="sender">Sender of the event</param>
/// <param name="e">Event parameters</param>
void Creation_Click(object sender, EventArgs e)
{
IBoxModule[] newBoxes = null;
BoxNode bn;
IBoxModule box;
//this prevents executing anything when the event is not called from the
//desktop (but from the main menu)
if (Hover == null)
{
bn = SelectedShapes[0] as BoxNode;
box = bn.Box;
}
else
{
bn = Hover as BoxNode;
box = bn.Box;
}
foreach (ModulesAskingForCreation info in box.ModulesAskingForCreation)
{
if (info.label == sender.ToString())
{
newBoxes = view.CreateBoxesAskingForCreation(info);
break;
}
}
//adding the individual boxes so we dont have to adapt the whole
//desktop
foreach (IBoxModule b in newBoxes)
{
//adding the box
BoxNode node = AddBox(b);
Connector from = null;
string socketName = string.Empty;
foreach (ProjectManager.Connection con in view.Connections)
{
//this is the right box (assuming there is only one box
//connected to the created box
if (con.ToBox == b)
{
from = FromConnector(con.FromBox);
socketName = con.ToSocket;
}
}
Connector to = ToConnector(b, socketName);
//We have to remove the handler because it would create a connection
//that is already there
OnNewConnection -= new NewConnection(FerdaDesktop_OnNewConnection);
//adding the connector
AddEdge(from, to);
//recreating the handler
OnNewConnection += new NewConnection(FerdaDesktop_OnNewConnection);
}
archiveDisplayer.Adapt();
}
///<summary>
///Redraws all shapes and connections according to a new state in
///the view object
///</summary>
///<remarks>
///Dont know if the control will remember previous shapes and connections
///and ask for the changed or write the entire structure over again...
///</remarks>
public void Adapt()
{
this.Hide();
Nodes.Clear();
selectedBoxes.Clear();
//We have to remove the handler because it would create a connection
//that is already there
OnNewConnection -= new NewConnection(FerdaDesktop_OnNewConnection);
//adding the boxes on the desktop
foreach ( IBoxModule box in view.Boxes)
{
BoxNode boxNode = new BoxNode(this, box, SvgManager, view, ResManager);
boxNode.X = view.GetPosition(box).X;
boxNode.Y = view.GetPosition(box).Y;
Nodes.Add(boxNode);
}
//adding the connections on the desktop
foreach (ProjectManager.Connection con in view.Connections)
{
//finding the from and to connectors
Connector from = FromConnector(con.FromBox);
Connector to = ToConnector(con.ToBox, con.ToSocket);
//adding the connector
AddEdge(from, to);
}
this.Show();
OnNewConnection += new NewConnection(FerdaDesktop_OnNewConnection);
}
