void MessageGridSelectionChanged(object sender, EventArgs e)
{
try
{
_fieldGrid.RowCount = 0;
_fieldTable.BeginLoadData();
_fieldTable.Clear();
Fix.Dictionary.Message message = SelectedMessage;
if (message == null)
{
return;
}
foreach (var field in message.Fields)
{
DataRow row = _fieldTable.NewRow();
row[FilterFieldDataTable.ColumnVisible] = Session.FieldVisible(message.MsgType, field.Tag);
row[FilterFieldDataTable.ColumnTag] = field.Tag;
row[FilterFieldDataTable.ColumnName] = field.Name;
_fieldTable.Rows.Add(row);
}
}
finally
{
_fieldTable.EndLoadData();
_fieldGrid.RowCount = _fieldTable.Rows.Count;
UpdateUiState();
}
}
void FieldGridCellContentClick(object sender, DataGridViewCellEventArgs e)
{
if (e.RowIndex < 0)
{
return;
}
if (_fieldGrid.Columns[e.ColumnIndex].Name != FilterFieldDataTable.ColumnVisible)
{
return;
}
DataRowView view = _fieldView[e.RowIndex];
DataRow dataRow = view.Row;
if (dataRow == null)
{
return;
}
Fix.Dictionary.Message message = SelectedMessage;
if (message == null)
{
return;
}
var visible = (bool)dataRow[FilterFieldDataTable.ColumnVisible];
var tag = (int)dataRow[FilterFieldDataTable.ColumnTag];
dataRow[FilterFieldDataTable.ColumnVisible] = !visible;
Session.FieldVisible(message.MsgType, tag, !visible);
}
void SetAllFieldsVisibility(bool visible)
{
try
{
Session.AutoWriteFilters = false;
_fieldTable.BeginLoadData();
Fix.Dictionary.Message message = SelectedMessage;
if (message == null)
{
return;
}
foreach (DataRow row in _fieldTable.Rows)
{
var tag = (int)row[FilterFieldDataTable.ColumnTag];
row[FilterFieldDataTable.ColumnVisible] = visible;
Session.FieldVisible(message.MsgType, tag, visible);
}
}
finally
{
_fieldTable.EndLoadData();
_fieldGrid.Refresh();
Session.AutoWriteFilters = true;
Session.WriteFilters();
}
}
static Fix.Message Expect(BlockingCollection <Fix.Message> messages, Fix.Dictionary.Message definition, IEnumerable <Fix.Field> expectedFields)
{
Assert.IsTrue(messages.TryTake(out Fix.Message message, Timeout), $"Timed out waiting for MsgType={definition.Name}");
Assert.AreEqual(definition.MsgType, message.MsgType, $"Found MsgType={MsgTypeName(message.MsgType)} when we expected MsgType={definition.Name}\n{message}");
if (expectedFields == null)
{
return(message);
}
var fields = message.Fields.GetEnumerator();
foreach (var expected in expectedFields)
{
Fix.Field actual;
for (; ;)
{
Assert.IsTrue(fields.MoveNext(), $"Expected field {expected} is not present or is not in the expected position");
actual = fields.Current;
if (actual.Tag == expected.Tag)
{
break;
}
}
Assert.AreEqual(expected.Value, actual.Value, $"{expected.Tag} = {actual.Value} when expecting {expected.Value}");
}
return(message);
}
public void TestDynamicFieldLookup()
{
Fix.Dictionary.Message message = Fix.Dictionary.FIX_4_0.Messages.Logon;
Assert.IsTrue(message.Fields.TryGetValue(10, out Fix.Dictionary.Field field));
Assert.AreEqual(10, field.Tag);
Assert.AreEqual("CheckSum", field.Name);
}
static string MsgTypeName(string msgType)
{
Fix.Dictionary.Message definition = Fix.Dictionary.Messages[msgType];
if (definition == null)
{
return(msgType);
}
return(definition.Name);
}
public void TestMessageMsgTypeLookup()
{
Fix.Dictionary.Message message = Fix.Dictionary.Messages["0"];
Assert.AreEqual("0", message.MsgType);
Assert.AreEqual("Heartbeat", message.Name);
message = Fix.Dictionary.Messages["A"];
Assert.AreEqual("A", message.MsgType);
Assert.AreEqual("Logon", message.Name);
}
void ExportButtonClick(object sender, EventArgs e)
{
string filename = Session.SenderCompId + "-" + Session.TargetCompId + ".txt";
using SaveFileDialog dlg = new();
dlg.Filter = "txt files (*.txt)|*.txt|All files (*.*)|*.*";
dlg.FilterIndex = 2;
dlg.RestoreDirectory = true;
dlg.FileName = filename;
dlg.Title = "Export";
if (dlg.ShowDialog() == DialogResult.OK)
{
Cursor original = Cursor.Current;
Cursor.Current = Cursors.WaitCursor;
try
{
using FileStream stream = new(dlg.FileName, FileMode.Create);
using StreamWriter writer = new(stream);
foreach (Fix.Message message in Session.Messages)
{
string timestamp = "Unknown";
Fix.Field field = message.Fields.Find(Fix.Dictionary.Fields.SendingTime.Tag);
if (field != null)
{
timestamp = field.Value;
}
string direction = message.Incoming ? "received" : "sent";
Fix.Dictionary.Message definition = Session.Version.Messages[message.MsgType];
writer.WriteLine("{0} ({1}) ({2})",
timestamp,
direction,
definition.Name);
writer.WriteLine("{");
writer.WriteLine(message.ToString());
writer.WriteLine("}");
}
}
finally
{
Cursor.Current = original;
}
}
}
protected void SendFromAcceptor(Fix.Dictionary.Message definition, IEnumerable <Fix.Field> fields = null)
{
var message = new Fix.Message {
MsgType = definition.MsgType
};
if (fields != null)
{
foreach (Fix.Field field in fields)
{
message.Fields.Add(field.Tag, field.Value);
}
}
Acceptor.Send(message);
}
public static Fix.Dictionary.Message MessageDefinition(Fix.Message message)
{
Fix.Field beginString = message.Fields.Find(Fix.Dictionary.Fields.BeginString);
Fix.Dictionary.Version version = null;
if (beginString != null && !beginString.Value.StartsWith("FIXT."))
{
version = Fix.Dictionary.Versions[beginString.Value];
}
if (version == null)
{
version = Fix.Dictionary.Versions.Default;
}
Fix.Dictionary.Message exemplar = version.Messages[message.MsgType];
if (exemplar == null)
{
return(Fix.Dictionary.Messages[message.MsgType]);
}
return(exemplar);
}
protected void SendFromInitiator(Fix.Dictionary.Message definition, IEnumerable <Fix.Field> fields = null)
{
var message = new Fix.Message {
MsgType = definition.MsgType
};
if (fields != null)
{
foreach (Fix.Field field in fields)
{
if (field.Tag == Fix.Dictionary.Fields.MsgSeqNum.Tag)
{
message.Fields.Set(field.Tag, field.Value);
}
else
{
message.Fields.Add(field.Tag, field.Value);
}
}
}
Initiator.Send(message);
}
public static Fix.Dictionary.Field FieldDefinition(Fix.Dictionary.Message message, Fix.Field field)
{
message.Fields.TryGetValue(field.Tag, out Fix.Dictionary.Field definition);
return(definition);
}
public MessageProperties(Fix.Dictionary.Message message)
{
_message = message;
}
protected void SentFromAcceptor(Fix.Dictionary.Message definition, IEnumerable <Fix.Field> fields = null)
{
Expect(_acceptorOutgoingMessages, definition, fields);
}
protected Fix.Message ReceiveAtAcceptor(Fix.Dictionary.Message definition, IEnumerable <Fix.Field> expectedFields = null)
{
return(Expect(_acceptorIncomingMessages, definition, expectedFields));
}
public void TestStaticMessageLookup()
{
Fix.Dictionary.Message message = Fix.Dictionary.Messages.Logon;
Assert.AreEqual("A", message.MsgType);
Assert.AreEqual("Logon", message.Name);
}
