private void OnProcessInvoked(Playbook playbook, TrackedProcessInvocation process)
{
var item = new ListViewItem(process.InstanceUID.ToString("D", CultureInfo.InvariantCulture)
+ (process.InvocationCounter > 1
? "/" + process.InvocationCounter.ToString("D", CultureInfo.InvariantCulture)
: ""))
{
Tag = process,
};
item.SubItems.Add("-");
item.SubItems.Add(process.Topic);
item.SubItems.Add(process.IdentedName);
item.SubItems.Add(process.KindToString());
item.SubItems.Add(process.Type);
item.SubItems.Add("0");
item.SubItems.Add("0");
item.SubItems.Add("0");
item.SubItems.Add("0");
item.SubItems.Add("0");
item.SubItems.Add("0").Tag = new Func <string>(() => process.GetFormattedRowFlow(Context));
item.Tag = process;
if (ListView.SelectedItems.Count == 0)
{
item.Selected = true;
}
if (process.Invoker != null && _itemsByProcessInvocationUid.TryGetValue(process.Invoker.InvocationUid, out var invokerItem))
{
var nextIndex = invokerItem.Index + 1;
while (nextIndex < _allItems.Count)
{
var p = _allItems[nextIndex].Tag as TrackedProcessInvocation;
if (!p.HasParent(process.Invoker))
{
break;
}
nextIndex++;
}
_allItems.Insert(nextIndex, item);
ListView.Items.Insert(nextIndex, item);
}
else
{
_allItems.Add(item);
ListView.Items.Add(item);
}
_itemsByProcessInvocationUid.Add(process.InvocationUid, item);
}
internal void SelectProcess(TrackedProcessInvocation process)
{
var item = _allItems.Find(x => x.Tag == process);
if (item?.Selected == false)
{
ListView.EnsureVisible(item.Index);
ListView.Focus();
item.Selected = true;
}
}
private void ProcessInvocationList_OnSelectionChanged(TrackedProcessInvocation process)
{
IoCommandList.HighlightedProcess = process;
}
public ProcessRowListControl(Control container, TrackedProcessInvocation process, List <TrackedRow> rows)
{
Container = container;
Process = process;
Rows = rows;
Updater = new ControlUpdater <ProcessRowModel>(null, Container, -1, 10)
{
ItemFilter = ItemFilter,
ContainsRows = true,
};
Updater.CreateSearchBox(10, 10);
ShowAll = new RadioButton()
{
Parent = container,
Bounds = new Rectangle(Updater.SearchBox.Right + 20, Updater.SearchBox.Top, 60, Updater.SearchBox.Height),
Text = "All",
CheckAlign = ContentAlignment.MiddleLeft,
Checked = process.Kind != ProcessKind.mutator,
};
ShowChanged = new RadioButton()
{
Parent = container,
Bounds = new Rectangle(ShowAll.Right + 20, Updater.SearchBox.Top, 75, Updater.SearchBox.Height),
Text = "Changed",
CheckAlign = ContentAlignment.MiddleLeft,
Checked = process.Kind == ProcessKind.mutator,
};
ShowUnChanged = new RadioButton()
{
Parent = container,
Bounds = new Rectangle(ShowChanged.Right + 20, Updater.SearchBox.Top, 100, Updater.SearchBox.Height),
Text = "Unchanged",
CheckAlign = ContentAlignment.MiddleLeft,
Checked = false,
};
ShowRemoved = new RadioButton()
{
Parent = container,
Bounds = new Rectangle(ShowUnChanged.Right + 20, Updater.SearchBox.Top, 75, Updater.SearchBox.Height),
Text = "Removed",
CheckAlign = ContentAlignment.MiddleLeft,
Checked = false,
};
ShowAll.CheckedChanged += (s, a) => Updater.RefreshItems(true);
ShowRemoved.CheckedChanged += (s, a) => Updater.RefreshItems(true);
ShowChanged.CheckedChanged += (s, a) => Updater.RefreshItems(true);
ShowUnChanged.CheckedChanged += (s, a) => Updater.RefreshItems(true);
Updater.ListView.Anchor = AnchorStyles.Top | AnchorStyles.Left | AnchorStyles.Right | AnchorStyles.Bottom;
Updater.ListView.Bounds = new Rectangle(Container.ClientRectangle.Left, Container.ClientRectangle.Top + 40, Container.ClientRectangle.Width, Container.ClientRectangle.Height - 40);
Updater.ListView.FormatCell += ListView_FormatCell;
Updater.ListView.UseCellFormatEvents = true;
Updater.ListView.CellToolTipShowing += ListView_CellToolTipShowing;
Updater.ListView.AllColumns.Add(new OLVColumn()
{
Text = "ID",
AspectGetter = x => (x as ProcessRowModel)?.RowUid,
});
Updater.ListView.AllColumns.Add(new OLVColumn()
{
Text = "Previous process",
AspectGetter = x => (x as ProcessRowModel)?.TrackedRow.PreviousProcess?.Name,
});
Updater.ListView.AllColumns.Add(new OLVColumn()
{
Text = "Next process",
AspectGetter = x => (x as ProcessRowModel)?.TrackedRow.NextProcess?.Name,
});
Updater.ListView.Columns.AddRange(Updater.ListView.AllColumns.ToArray());
_fixColumnCount = Updater.ListView.Columns.Count;
var newColumns = new List <OLVColumn>();
var items = new List <ProcessRowModel>();
foreach (var row in rows)
{
foreach (var kvp in row.NewValues)
{
AddColumnByValue(newColumns, kvp);
}
if (row.PreviousValues != null)
{
foreach (var kvp in row.PreviousValues)
{
AddColumnByValue(newColumns, kvp);
}
}
var item = new ProcessRowModel()
{
TrackedRow = row,
RowUid = row.Uid,
NewValues = new object[newColumns.Count / 2],
NewTypes = new string[newColumns.Count / 2],
PreviousValues = row.PreviousValues != null ? new object[newColumns.Count / 2] : null,
PreviousTypes = row.PreviousValues != null ? new string[newColumns.Count / 2] : null,
};
if (row.PreviousValues != null)
{
foreach (var kvp in row.PreviousValues)
{
var valueIndex = _columnIndexes[kvp.Key] / 2;
item.PreviousValues[valueIndex] = kvp.Value;
item.PreviousTypes[valueIndex] = kvp.Value?.GetType().GetFriendlyTypeName();
}
if (row.NewValues.Count == row.PreviousValues.Count)
{
foreach (var kvp in row.NewValues)
{
row.PreviousValues.TryGetValue(kvp.Key, out var previousValue);
row.NewValues.TryGetValue(kvp.Key, out var newValue);
if (!DefaultValueComparer.ValuesAreEqual(previousValue, newValue))
{
item.Changed = true;
}
}
}
else
{
item.Changed = true;
}
}
foreach (var kvp in row.NewValues)
{
var valueIndex = _columnIndexes[kvp.Key] / 2;
item.NewValues[valueIndex] = kvp.Value;
item.NewTypes[valueIndex] = kvp.Value?.GetType().GetFriendlyTypeName();
}
Updater.AddItem(item);
}
Updater.ListView.Columns.AddRange(newColumns.ToArray());
Updater.Start();
}
public void AddEvents(IEnumerable <AbstractEvent> abstactEvents)
{
var newEvents = new List <AbstractEvent>();
foreach (var abstactEvent in abstactEvents)
{
switch (abstactEvent)
{
case LogEvent evt:
{
if (evt.ProcessInvocationUID != null && !ProcessList.ContainsKey(evt.ProcessInvocationUID.Value))
{
continue;
}
}
break;
case IoCommandStartEvent evt:
{
if (!ProcessList.ContainsKey(evt.ProcessInvocationUid))
{
continue;
}
}
break;
case ProcessInvocationStartEvent evt:
{
if (!ProcessList.ContainsKey(evt.InvocationUID))
{
TrackedProcessInvocation invoker = null;
if (evt.CallerInvocationUID != null && !ProcessList.TryGetValue(evt.CallerInvocationUID.Value, out invoker))
{
continue;
}
var process = new TrackedProcessInvocation(evt.InvocationUID, evt.InstanceUID, evt.InvocationCounter, invoker, evt.Type, evt.Kind, evt.Name, evt.Topic);
ProcessList.Add(process.InvocationUid, process);
OnProcessInvoked?.Invoke(this, process);
}
}
break;
case ProcessInvocationEndEvent evt:
{
if (!ProcessList.TryGetValue(evt.InvocationUID, out var process))
{
continue;
}
process.ElapsedMillisecondsAfterFinished = TimeSpan.FromMilliseconds(evt.ElapsedMilliseconds);
if (evt.NetTimeMilliseconds != null)
{
process.NetTimeAfterFinished = TimeSpan.FromMilliseconds(evt.NetTimeMilliseconds.Value);
}
}
break;
case RowCreatedEvent evt:
{
if (!ProcessList.TryGetValue(evt.ProcessInvocationUid, out var process))
{
continue;
}
process.CreateRow();
}
break;
case RowOwnerChangedEvent evt:
{
if (!ProcessList.TryGetValue(evt.PreviousProcessInvocationUid, out var previousProcess))
{
continue;
}
TrackedProcessInvocation newProcess = null;
if (evt.NewProcessInvocationUid != null && !ProcessList.TryGetValue(evt.NewProcessInvocationUid.Value, out newProcess))
{
continue;
}
if (newProcess != null)
{
previousProcess.PassedRow(evt.RowUid);
newProcess.InputRow(evt.RowUid, previousProcess);
}
else
{
previousProcess.DropRow(evt.RowUid);
}
}
break;
case RowValueChangedEvent evt:
continue;
case SinkStartedEvent evt:
{
var sink = new TrackedSink(evt.UID, evt.Location, evt.Path);
SinkList.Add(evt.UID, sink);
OnSinkStarted?.Invoke(this, sink);
}
break;
case WriteToSinkEvent evt:
{
if (!ProcessList.TryGetValue(evt.ProcessInvocationUID, out var process))
{
continue;
}
if (!SinkList.TryGetValue(evt.SinkUID, out var sink))
{
continue;
}
process.WriteRowToSink(evt.RowUid);
OnWriteToSink?.Invoke(this, sink, process, evt.RowUid, evt.Values);
sink.RowCount++;
}
break;
}
newEvents.Add(abstactEvent);
}
if (newEvents.Count == 0)
{
return;
}
OnEventsAdded?.Invoke(this, newEvents);
}
