/// <summary>
/// Try binding data record to <see cref="XText.Text"/> shape property containing column name.
/// </summary>
/// <param name="r">The external data record used for binding.</param>
/// <param name="columnName">The column name.</param>
/// <param name="value">The output string bound to data record.</param>
/// <returns>True if binding was successful.</returns>
private static bool TryToBind(XRecord r, string columnName, out string value)
{
if (string.IsNullOrEmpty(columnName) || r == null)
{
value = null;
return(false);
}
var columns = r.Columns;
var values = r.Values;
if (columns == null || values == null || columns.Length != values.Length)
{
value = null;
return(false);
}
for (int i = 0; i < columns.Length; i++)
{
if (columns[i].Name == columnName)
{
value = values[i].Content;
return(true);
}
}
value = null;
return(false);
}
public void all_predicates()
{
XRecord record;
DnsName owner = DnsName.Parse("test.com.");
byte[] rdata = new byte[0];
DnsRecordType[] allRecordTypes = (DnsRecordType[])Enum.GetValues(typeof(DnsRecordType));
foreach (PredicateTestCase @case in PREDICATE_TEST_CASES)
{
Assert.IsFalse(@case.Predicate(null));
foreach (DnsRecordType type in @case.Types)
{
record = new XRecord(owner, type, DnsRecordClass.IN, TimeSpan.FromHours(1), rdata);
Assert.IsTrue(@case.Predicate(record), "{0} expected to return true for {1}", @case.Predicate.Method, type);
}
foreach (DnsRecordType type in allRecordTypes)
{
if ([email protected](type))
{
record = new XRecord(owner, type, DnsRecordClass.IN, TimeSpan.FromHours(1), rdata);
Assert.IsFalse(@case.Predicate(record), "{0} expected to return false for {1}", @case.Predicate.Method, type);
}
}
}
}
/// <summary>
/// Creates a new <see cref="XContext"/> instance.
/// </summary>
/// <param name="record">The record instance.</param>
/// <returns>The new instance of the <see cref="XContext"/> class.</returns>
public static XContext Create(XRecord record)
{
return(new XContext()
{
Record = record
});
}
public R20RecordTests()
{
var record = new XRecord("BatchHeaderRecord", "20");
var meta = Builder.GetMeta()[record];
_data = Builder.GetTestStringFor(meta);
_sut = new R20();
_sut.SetData(_data);
}
public R50RecordTests()
{
var record = new XRecord("ImageViewDetailRecord", "50");
var meta = Builder.GetMeta()[record];
_data = Builder.GetTestStringFor(meta);
_sut = new R50();
_sut.SetData(_data);
}
public R01RecordTests()
{
var record = new XRecord("FileHeaderRecord", "01");
var meta = Builder.GetMeta()[record];
_data = Builder.GetTestStringFor(meta);
_sut = new R01();
_sut.SetData(_data);
}
public R70RecordTests()
{
var record = new XRecord("BatchControlRecord", "70");
var meta = Builder.GetMeta()[record];
_data = Builder.GetTestStringFor(meta);
_sut = new R70();
_sut.SetData(_data);
}
public R10RecordTests()
{
var record = new XRecord("CashLetterHeaderRecord", "10");
var meta = Builder.GetMeta()[record];
_data = Builder.GetTestStringFor(meta);
_sut = new R10();
_sut.SetData(_data);
}
public R90RecordTests()
{
var record = new XRecord("CashLetterControlRecord", "90");
var meta = Builder.GetMeta()[record];
_data = Builder.GetTestStringFor(meta);
_sut = new R90();
_sut.SetData(_data);
}
public R25RecordTests()
{
var record = new XRecord("CheckDetailRecord", "25");
var meta = Builder.GetMeta()[record];
_data = Builder.GetTestStringFor(meta);
_sut = new R25();
_sut.SetData(_data);
}
public R61RecordTests()
{
var record = new XRecord("CreditDetailRecord", "61");
var meta = Builder.GetMeta()[record];
_data = Builder.GetTestStringFor(meta);
_sut = new R61();
_sut.SetData(_data);
}
public R99RecordTests()
{
var record = new XRecord("FileControlRecord", "99");
var meta = Builder.GetMeta()[record];
_data = Builder.GetTestStringFor(meta);
_sut = new R99();
_sut.SetData(_data);
}
/// <summary>
/// Set data record.
/// </summary>
/// <param name="project">The project instance.</param>
/// <param name="data">The data instance.</param>
/// <param name="record">The record instance.</param>
public static void ApplyRecord(this XProject project, XContext data, XRecord record)
{
if (data != null && record != null)
{
var previous = data.Record;
var next = record;
project?.History?.Snapshot(previous, next, (p) => data.Record = p);
data.Record = next;
}
}
/// <summary>
/// Add record to database records collection.
/// </summary>
/// <param name="project">The project instance.</param>
/// <param name="db">The database instance.</param>
/// <param name="record">The record instance.</param>
public static void AddRecord(this XProject project, XDatabase db, XRecord record)
{
if (db?.Records != null)
{
var previous = db.Records;
var next = db.Records.Add(record);
project?.History?.Snapshot(previous, next, (p) => db.Records = p);
db.Records = next;
}
}
public R52RecordTests()
{
var record = new XRecord("ImageViewDataRecord", "52");
var meta = Builder.GetMeta()[record];
var data = Builder.GetTestStringFor(meta);
_data = data.Substring(0, 117);
_optional = System.Text.Encoding.ASCII.GetBytes(data.Substring(117));
_sut = new R52();
_sut.SetData(_data, _optional);
}
public void TestThat_ARecordWithNull_AreNotEqual(string name, string typeId)
{
// Arrange
var record = new XRecord(name, typeId);
// Act
var result = record == null || null == record;
// Assert
Assert.False(result);
}
/// <summary>
/// Remove record from database records collection.
/// </summary>
/// <param name="project">The project instance.</param>
/// <param name="record">The record instance.</param>
public static void RemoveRecord(this XProject project, XRecord record)
{
var db = record?.Owner;
if (db != null && db.Records != null)
{
var previous = db.Records;
var next = db.Records.Remove(record);
project?.History?.Snapshot(previous, next, (p) => db.Records = p);
db.Records = next;
}
}
public void TestThat_SameRecordsAsObject_AreEqual(string name1, string typeId1, string name2, string typeId2)
{
// Arrange
var record1 = new XRecord(name1, typeId1);
var record2 = new XRecord(name2, typeId2);
// Act
var result = record1.Equals((object)record2);
// Assert
Assert.True(result);
}
public void TestThat_DifferentRecords_AreNotEqual(string name1, string typeId1, string name2, string typeId2)
{
// Arrange
var record1 = new XRecord(name1, typeId1);
var record2 = new XRecord(name2, typeId2);
// Act
var result = record1 != record2;
// Assert
Assert.True(result);
}
public void TestThat_ExactSameRecords_AreEqual(string name, string typeId)
{
// Arrange
var record1 = new XRecord(name, typeId);
var record2 = record1;
// Act
var result = record1 == record2;
// Assert
Assert.True(result);
}
/// <summary>
/// Bind properties or data record to <see cref="XText.Text"/> property.
/// </summary>
/// <param name="db">The properties database used for binding.</param>
/// <param name="r">The external data record used for binding.</param>
/// <returns>The string bound to properties or data record.</returns>
public string BindText(ImmutableArray <XProperty> db, XRecord r)
{
var record = this.Data.Record ?? r;
if (!string.IsNullOrEmpty(_text))
{
var text = _text.Trim();
if (text.Length >= 3 && text.TrimStart().StartsWith("{") && text.TrimEnd().EndsWith("}"))
{
var bidning = text.Substring(1, text.Length - 2);
// Try to bind to internal Data.Record or external (r) data record using Text property as Column.Name name.
if (record != null)
{
string value;
bool success = TryToBind(record, bidning, out value);
if (success)
{
return(value);
}
}
// Try to bind to external Properties database (e.g. Container.Data.Properties) using Text property as Property.Name name.
if (db != null)
{
string value;
bool success = TryToBind(db, bidning, out value);
if (success)
{
return(value);
}
}
}
}
// Try to bind to Properties using Text as formatting.
if (this.Data.Properties != null && this.Data.Properties.Length > 0)
{
try
{
var args = this.Data.Properties.Where(x => x != null).Select(x => x.Value).ToArray();
if (_text != null && args != null && args.Length > 0)
{
return(string.Format(_text, args));
}
}
catch (FormatException) { }
}
return(_text);
}
private void Add(XRecord record)
{
if (record == null)
{
return;
}
record.PropertyChanged += ObserveRecord;
if (record.Values != null)
{
Add(record.Values);
}
}
private void Remove(XRecord record)
{
if (record == null)
{
return;
}
record.PropertyChanged -= ObserveRecord;
if (record.Values != null)
{
Remove(record.Values);
}
}
public void TestThatRecords_ReturnsExactObject(string name, string typeId)
{
// Arrange
var record = new XRecord(name, typeId);
// Act
var obj = Builder.GetObjectFor(record);
var sut = Builder.GetObjectFor(record);
// Assert
var ret = sut.Equals(obj);
Assert.True(ret);
}
public void TestThatRecords_ReturnsExpectedObject(string name, string typeId, bool isUnknown)
{
// Arrange
var record = new XRecord(name, typeId);
// Act
var obj = Builder.GetObjectFor(record);
// Assert
if (isUnknown)
{
Assert.True(obj is Unknown);
}
else
{
Assert.True(!(obj is Unknown));
}
}
public void TestThatGenerate_ReturnsExpectedCode(string recordName, string recordType)
{
// Arrange
var key = new XRecord(recordName, recordType);
var meta = Builder.GetMeta()[key];
// Act
var code = Builder.GetClassFor(key);
// Assert
foreach (var field in meta)
{
if (field.FieldName == "RecordType")
{
continue; // base class, all have it
}
// Set Data bits
if (field.DataType != DataType.Binary)
{
Assert.Contains($"{field.FieldName} = Data.Substring({field.Position.Start}, {field.Size})", code);
}
else
{
//, Data.Length
Assert.Contains($"{field.FieldName} = optional;", code);
}
// Property bits
var dataType = "string";
if (field.DataType == DataType.Binary)
{
dataType = "byte[]";
}
Assert.Contains($"public {dataType} {field.FieldName} {{ get; set; }}", code);
}
}
public void TestMeta_ObjectFieldLength(string recordName, string recordType, int expectedLength)
{
// Arrange
var key = new XRecord(recordName, recordType);
var meta = _metadata[key];
var record = Builder.GetObjectFor(key);
// Act
var size = meta.Where(x => x.DataType != DataType.Binary).Sum(x => x.Size);
var props = record.GetType().GetProperties().Select(x => x.Name).ToList();
var mprops = meta.Select(x => x.FieldName).ToList();
mprops.Sort();
props.Sort();
// Assert
Assert.Equal(expectedLength, size);
// This is great if you don't care to know what field is missing or wrong
//Assert.Equal(mprops, props);
foreach (var field in mprops)
{
Assert.Contains(field, props);
}
}
/// <summary>
///
/// </summary>
/// <param name="shapes"></param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="properties"></param>
/// <param name="record"></param>
/// <param name="ic"></param>
public static void SetClipboard(IEnumerable <BaseShape> shapes, double width, double height, ImmutableArray <XProperty> properties, XRecord record, IImageCache ic)
{
try
{
using (var bitmap = new Bitmap((int)width, (int)height))
{
using (var ms = MakeMetafileStream(bitmap, shapes, properties, record, ic))
{
var data = new WPF.DataObject();
data.SetData(WPF.DataFormats.EnhancedMetafile, ms);
WPF.Clipboard.SetDataObject(data, true);
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
Debug.WriteLine(ex.StackTrace);
}
}
/// <inheritdoc/>
public override void Draw(object dc, ShapeRenderer renderer, double dx, double dy, ImmutableArray <XProperty> db, XRecord r)
{
var record = this.Data.Record ?? r;
if (State.Flags.HasFlag(ShapeStateFlags.Visible))
{
renderer.Draw(dc, this, dx, dy, db, record);
}
if (renderer.State.SelectedShape != null)
{
if (this == renderer.State.SelectedShape)
{
_topLeft.Draw(dc, renderer, dx, dy, db, record);
_bottomRight.Draw(dc, renderer, dx, dy, db, record);
}
else if (_topLeft == renderer.State.SelectedShape)
{
_topLeft.Draw(dc, renderer, dx, dy, db, record);
}
else if (_bottomRight == renderer.State.SelectedShape)
{
_bottomRight.Draw(dc, renderer, dx, dy, db, record);
}
}
if (renderer.State.SelectedShapes != null)
{
if (renderer.State.SelectedShapes.Contains(this))
{
_topLeft.Draw(dc, renderer, dx, dy, db, record);
_bottomRight.Draw(dc, renderer, dx, dy, db, record);
}
}
}
/// <summary>
///
/// </summary>
/// <param name="bitmap"></param>
/// <param name="shapes"></param>
/// <param name="properties"></param>
/// <param name="record"></param>
/// <param name="ic"></param>
/// <returns></returns>
public static MemoryStream MakeMetafileStream(Bitmap bitmap, IEnumerable <BaseShape> shapes, ImmutableArray <XProperty> properties, XRecord record, IImageCache ic)
{
var g = default(Graphics);
var mf = default(Metafile);
var ms = new MemoryStream();
try
{
using (g = Graphics.FromImage(bitmap))
{
var hdc = g.GetHdc();
mf = new Metafile(ms, hdc);
g.ReleaseHdc(hdc);
}
using (g = Graphics.FromImage(mf))
{
var r = new WinFormsRenderer(72.0 / 96.0);
r.State.DrawShapeState.Flags = ShapeStateFlags.Printable;
r.State.ImageCache = ic;
g.SmoothingMode = SmoothingMode.HighQuality;
g.PixelOffsetMode = PixelOffsetMode.HighQuality;
g.TextRenderingHint = TextRenderingHint.ClearTypeGridFit;
g.CompositingQuality = CompositingQuality.HighQuality;
g.InterpolationMode = InterpolationMode.HighQualityBicubic;
g.PageUnit = GraphicsUnit.Display;
if (shapes != null)
{
foreach (var shape in shapes)
{
shape.Draw(g, r, 0, 0, properties, record);
}
}
r.ClearCache(isZooming: false);
}
}
finally
{
if (g != null)
{
g.Dispose();
}
if (mf != null)
{
mf.Dispose();
}
}
return(ms);
}
