void CreateItem(ITopologyItem n, Point location)
{
if (n == null)
{
return;
}
UCTopologyItem top = new UCTopologyItem(n);
top.Location = location;
n.Tag = top;
top.RefreshInPlay(_InPlay);
top.MouseDown += pictureBox1_MouseDown;
top.MouseMove += pictureBox1_MouseMove;
pItems.Controls.Add(top);
n.OnProcess += Item_OnProcess;
_List.Add(top);
if (n is IDataInput)
{
IDataInput i = (IDataInput)n;
_Inputs.Add(i);
if (_InPlay)
{
_Inputs.Stop();
_Inputs.Start();
}
}
Select(top);
}
public UCTopologyItem(ITopologyItem v) : this()
{
Item = v;
AreInUse = new AreInUse();
_IsDataInput = Item == null || Item is IDataInput;
RefreshDesign();
if (_IsDataInput)
{
Size = new Size((int)(Width * 1.2), (int)(Height * 1.2));
}
if (!_IsDataInput && SystemHelper.IsWindows)
{
using (Graphics gp = CreateGraphics())
{
if (_IsDataInput)
{
_EdgeFilter = RectangleEdgeFilter.BottomLeft | RectangleEdgeFilter.TopRight;
}
else
{
_EdgeFilter = RectangleEdgeFilter.All;
}
_EdgeBorder = 10F;
Region = new Region(gp.GenerateRoundedRectangle(Bounds, _EdgeBorder, _EdgeFilter));
}
}
else
{
_EdgeFilter = RectangleEdgeFilter.None;
_EdgeBorder = 0;
}
}
void M_Click(object sender, EventArgs e)
{
ToolStripMenuItem t = (ToolStripMenuItem)sender;
ITopologyItem n = (ITopologyItem)Activator.CreateInstance((Type)t.Tag);
CreateItem(n, Point.Empty);
}
void AddItem(ITopologyItem n, ToolStripMenuItem parent)
{
ToolStripMenuItem m = new ToolStripMenuItem();
m.Text = n.Title;
m.ForeColor = n.DesignForeColor;
m.BackColor = n.DesignBackColor;
m.Tag = n.GetType();
parent.DropDownItems.Add(m);
m.Click += M_Click;
}
static void ITopologyItem_OnException(ITopologyItem sender, Exception e)
{
if (e == null)
{
return;
}
if (Environment.UserInteractive)
{
MessageBox.Show(e.ToString(), "ERROR", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
else
{
File.WriteAllLines(Path.Combine(Path.GetDirectoryName(Application.ExecutablePath), "error.log"), new string[] { e.ToString() });
}
}
void ITopologyItem_OnException(ITopologyItem sender, Exception e)
{
if (InvokeRequired)
{
Invoke(new ITopologyItem.delOnException(ITopologyItem_OnException), sender, e);
return;
}
if (_InPlay)
{
// Stop-it
playToolStripMenuItem_Click(null, null);
}
rError.Text = e.ToString();
pError.Visible = true;
}
public bool IsAllowed(UCTopologyItem to)
{
if (to == null)
{
return(false);
}
ITopologyItem tfrom = FromItem;
ITopologyItem tto = to.Item;
if (tfrom is IDataInput || tfrom is IDataProcess)
{
return(tto is IDataProcess);
}
return(false);
}
void propertyGrid1_PropertyValueChanged(object s, PropertyValueChangedEventArgs e)
{
if (propertyGrid1.SelectedObject is ITopologyItem)
{
ITopologyItem t = (ITopologyItem)propertyGrid1.SelectedObject;
pItems.Invalidate(true);
UCTopologyItem c = SearchControl(t);
if (c != null)
{
c.RefreshDesign();
}
for (int x = 0; x < _List.Count; x++)
{
_List.ResetItem(x);
}
}
}
UCTopologyItem SearchControl(ITopologyItem item)
{
if (item == null)
{
return(null);
}
if (item.Tag != null && item.Tag is UCTopologyItem)
{
return((UCTopologyItem)item.Tag);
}
foreach (UCTopologyItem c in pItems.Controls)
{
if (c.Item == item)
{
return(c);
}
}
return(null);
}
public bool Apply(UCTopologyItem top)
{
if (!IsAllowed(top))
{
return(false);
}
ITopologyItem to = top.Item;
if (to is IDataProcess)
{
DataProcessCollection proc = From.Item.Process;
if (!proc.Contains((IDataProcess)to))
{
proc.Add((IDataProcess)to);
To = top;
return(true);
}
}
return(false);
}
public void LoadActions(Assembly asm)
{
Type tin = typeof(IDataInput);
Type tpr = typeof(IDataProcess);
Type ti = typeof(ITopologyItem);
foreach (Type t in asm.GetTypes())
{
if (t == tin || t == tpr)
{
continue;
}
if (!t.IsPublic)
{
continue;
}
if (!ReflectionHelper.HavePublicConstructor(t))
{
continue;
}
if (!ti.IsAssignableFrom(t))
{
continue;
}
using (ITopologyItem d = (ITopologyItem)Activator.CreateInstance(t))
{
if (tin.IsAssignableFrom(t))
{
AddItem(d, inputToolStripMenuItem);
}
else if (tpr.IsAssignableFrom(t))
{
AddItem(d, processToolStripMenuItem);
}
}
}
}
void Item_OnProcess(ITopologyItem sender, EProcessState state)
{
if (sender == null)
{
return;
}
UCTopologyItem uc = (UCTopologyItem)sender.Tag;
if (uc != null)
{
// Activamos el procesado
uc.AreInUse.InUse = state == EProcessState.PreProcess;
uc.Invalidate();
}
// Controlamos las lineas de conexión
foreach (ConnectedLine l in _Lines)
{
if (state == EProcessState.PreProcess)
{
// Desactivar todas las lineas que iban a él
if (l.ToItem == sender)
{
l.AreInUse.InUse = false;
}
}
else
{
// Activar todas las lineas que salen de él
if (l.FromItem == sender)
{
l.AreInUse.InUse = true;
}
}
}
pItems.Invalidate(false);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="source">Origen de datos</param>
internal DataEmpty(ITopologyItem source) : base(source)
{
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="source">Origen de datos</param>
/// <param name="items">Items</param>
internal DataArray(ITopologyItem source, IList <object> items) : base(source)
{
_Items = items.ToArray();
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="source">Origen de datos</param>
/// <param name="items">Items</param>
internal DataArray(ITopologyItem source, object[] items) : base(source)
{
_Items = items;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="source">Origen de datos</param>
/// <param name="data">Datos</param>
internal DataObject(ITopologyItem source, object data) : base(source)
{
Data = data;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="parent">Padre</param>
public DataProcessCollection(ITopologyItem parent)
{
_Parent = parent;
}
/// <summary>
/// Procesa los datos de entrada
/// </summary>
/// <param name="source">Origen</param>
/// <param name="data">Datos</param>
/// <param name="useParallel">Usar paralelismo</param>
public void ProcessData(ITopologyItem source, IData data, bool useParallel)
{
if (data == null)
{
return;
}
// Si es un enumerador, hay que pasar fila a fila al procesado
if (data is DataEnumerable)
{
// Lo ejecuta secuencial
using (IEnumerator <object> enumerator = ((DataEnumerable)data).GetEnumerator())
{
EEnumerableDataState state = EEnumerableDataState.Start;
bool last = !enumerator.MoveNext();
IData current;
while (!last)
{
current = new DataObject(data.Source, enumerator.Current);
last = !enumerator.MoveNext();
if (last)
{
// Si es el último y era el primero, solo hay uno, sino, ha llegado al final
if (state == EEnumerableDataState.Start)
{
state = EEnumerableDataState.OnlyOne;
}
else
{
state = EEnumerableDataState.End;
}
}
// Ejecuta el procesado
if (useParallel && Count > 1)
{
//Parallel.For(0, Count, i => { this[i].ProcessData(current, i, state); });
Parallel.ForEach <IDataProcess>(this, p => { p.ProcessData(data, source, state); });
}
else
{
foreach (IDataProcess p in this)
{
p.ProcessData(current, source, state);
}
}
state = EEnumerableDataState.Middle;
}
}
// Liberar los recursos del enumerado, posiblemente no se pueda reutilizar
data.Dispose();
}
else
{
// Ejecuta el procesado
if (useParallel && Count > 1)
{
//Parallel.For(0, Count, i => { this[i].ProcessData(data, i, EEnumerableDataState.NonEnumerable); });
Parallel.ForEach <IDataProcess>(this, p => { p.ProcessData(data, source, EEnumerableDataState.NonEnumerable); });
}
else
{
foreach (IDataProcess p in this)
{
p.ProcessData(data, source, EEnumerableDataState.NonEnumerable);
}
}
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="source">Origen de datos</param>
/// <param name="items">Items</param>
internal DataJoin(ITopologyItem source, params IData[] items) : base(source)
{
_Items = items;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="source">Origen de datos</param>
/// <param name="objs">Objetos</param>
internal DataEnumerable(ITopologyItem source, IEnumerable <object> objs) : base(source)
{
_Objects = objs;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="source">Origen de datos</param>
internal DataBreak(ITopologyItem source) : base(source)
{
}
public ObjectCache(PropertyInfo propertyInfo, ITopologyItem item)
{
_PropertyInfo = propertyInfo;
_Item = item;
_Value = propertyInfo.GetValue(item);
}
