/// <inheritdoc />
public bool TryGetBindingData(string serviceName, out IBindingData bindingData)
{
GuardNotDisposingOrDisposed();
Guard.RequireNotNullOrEmpty <ArgumentException>(serviceName, $"Invalid '{nameof(serviceName)}'.");
serviceName = Dealias(serviceName);
return(m_ServiceNameToBindingDataMap.TryGetValue(serviceName, out bindingData));
}
internal protected BindingDataLinearMap(IBindingData bindData,
double scale, double offset
)
{
data = bindData;
this.scale = scale;
this.offset = offset;
Name = data.Name;
}
public static BindingDataLinearMap FromBindingDataLinearMap(IBindingData bd)
{
if (bd == null)
{
throw new ArgumentException("'bs' is null");
}
return(new BindingDataLinearMap(bd));
}
/// <summary>
/// Estimate of column from Main DataMember
/// </summary>
/// <param name="point">The point that we want estimate columns</param>
/// <returns></returns>
public object EstimateByNearestColumnsInDataMember(Point point)
{
IBindingData bd = Parent.Chart.DataMember;
if (bd == null)
{
throw new Exception("DataMember of chart not define");
}
return(EstimateByNearestColumns(point, bd));
}
public static BindingDataLinearMap FromBindingDataLinearMap(IBindingData bd,
double scale, double offset
)
{
if (bd == null)
{
throw new ArgumentException("'bs' is null");
}
return(new BindingDataLinearMap(bd, scale, offset));
}
public RequestBindingContext(RequestMetadata metadata, IBindingData bindingSource)
{
metadata.AssertNotNull(nameof(metadata));
bindingSource.AssertNotNull(nameof(bindingSource));
Metadata = metadata;
BindingSource = bindingSource;
Timeout = metadata.Timeout;
Route = metadata.Route;
}
private BaseServiceInspector CreateInspectorOrNull(IBindingData bindingData)
{
var implType = bindingData.ImplType;
var lifeCycleManaged = bindingData.LifeCycleManaged;
if (!lifeCycleManaged || !m_TypeToInspectorTypeMap.TryGetValue(implType, out var inspectorType))
{
return(null);
}
return((BaseServiceInspector)Activator.CreateInstance(inspectorType));
}
private IBindingData FindIBindingData(int indexRow, out int i)
{
IBindingData bs = null;
i = 0;
while (indexRow >= rowsCountF[i])
{
i++;
}
i--;
bs = lst[i];
return(bs);
}
internal protected BindingMultiIBindingData(params IBindingData[] bds)
{
if (bds.Length < 1)
{
throw new Exception("Enter IBindingData(s)!");
}
lst = new List <IBindingData>();
lst.AddRange(bds);
UpdateCount();
columnName = lst[0];
}
/// <summary>
/// Estimate of column from Second DataMember
/// </summary>
/// <param name="point">The point that we want estimate columns</param>
/// <returns></returns>
public object EstimateByNearestColumnsInSecondDataMember(Point point)
{
if (this.SecondDataMember == null)
{
throw new Exception("SecondDataMember not define");
}
IBindingData bd = this.SecondDataMember.DataMember;
if (bd == null)
{
throw new Exception("DataMember of SecondDataMember not define");
}
return(EstimateByNearestColumns(point, bd));
}
public override object ValueObject(int indexRow, int indexColumn)
{
try
{
if (indexRow < countRow)
{
IBindingData bs = FindIBindingData(indexRow, out int inx);
if (bs != null && indexColumn < bs.ColumnCount)
{
return(bs.ValueObject(indexRow - rowsCountF[inx], indexColumn));
}
}
}
catch { }
return(null);
}
public override bool Valid(int indexRow, int indexColumn)
{
try
{
if (indexRow < countRow)
{
IBindingData bs = FindIBindingData(indexRow, out int inx);
if (bs != null && indexColumn < bs.ColumnCount)
{
return(bs.Valid(indexRow - rowsCountF[inx], indexColumn));
}
}
}
catch { }
return(false);
}
private object EstimateByNearestColumns(Point point, IBindingData bd)
{
NearestColumnsIndex(point, out int befor, out int after);
if (befor == -1 && after == -1)
{
return(null);
}
if (befor == -1)
{
return(bd.ColumnValue(pointLocation[after].ColIndex));
}
if (after == -1)
{
return(bd.ColumnValue(pointLocation[befor].ColIndex));
}
if (after == befor)
{
return(bd.ColumnValue(pointLocation[after].ColIndex));
}
ItemPointInfo l = pointLocation[befor];
ItemPointInfo g = pointLocation[after];
double x1 = l.Center.X;
double x2 = g.Center.X;
double y1 = bd.ColumnValue(l.ColIndex);
double y2 = bd.ColumnValue(g.ColIndex);
double x = point.X;
double y = 0;
if (x1 == x2) //Not equal but for ....
{
y = y1;
}
else
{
double m = (y1 - y2) / (x1 - x2);
y = m * (x - x1) + y1;
}
return(bd.CalculateColumnValue(y));
}
protected override void InternalPaintFinish(Graphics grChart, IBindingData data)
{
//TODO : active VerticalGrid in BackOfData
if (this.VerticalGrid != HorizontalGridMode.None)
{
Pen penGrid = new Pen(base.GridColor, 1);
AxileBase.SetDashStyle(penGrid, this.GridDashStyle);
int wBegin = (int)this.DrawArea.Top;
int wEnd = (int)this.DrawArea.Bottom;
foreach (AxileLabelText dt in LabelsX)
{
ItemPointInfo ipi = new ItemPointInfo
{
ColIndex = -1
};
foreach (ItemPointInfo ipi2 in pointLocation)
{
if (ipi2.ColIndex == dt.ColumnIndex)
{
ipi = ipi2;
break;
}
}
if (ipi.ColIndex != -1)
{
int x = (int)(ipi.Center.X);
grChart.DrawLine(penGrid, x, wBegin, x, wEnd);
}
else
{
grChart.FillRectangle(Brushes.DarkKhaki, dt.Rectangle);
}
}
penGrid.Dispose();
}
}
public static void FindMaxMin(IBindingData data, ref double max, ref double min)
{
int rowIndex, colIndex;
max = 0;
min = 0;
for (rowIndex = 0; rowIndex < data.RowCount; rowIndex++)
{
for (colIndex = 0; colIndex < data.ColumnCount; colIndex++)
{
double d = data.ValueDouble(rowIndex, colIndex);
if (d > max)
{
max = d;
}
if (d < min)
{
min = d;
}
}
}
}
protected override void InternalPaintStart(Graphics grChart, IBindingData data)
{
barLocation.Clear();
}
public IRestRequest MapRequest(RequestMetadata metadata, IBindingData bindingSource)
{
metadata.AssertNotNull(nameof(metadata));
bindingSource.AssertNotNull(nameof(bindingSource));
var bindingContext = new RequestBindingContext(metadata, bindingSource);
foreach (var binder in RequestBinders)
{
binder.Bind(bindingContext);
}
//TODO validate
//bindingContext.Validate();
if (bindingContext.FormFiles.Any())
{
throw new NotImplementedException();//TODO !
}
var request = new RestRequest()
{
Method = bindingContext.Metadata.Method,
Route = bindingContext.Route,
Timeout = bindingContext.Timeout
};
//TODO !!!
if (bindingContext.FormFields.Any())
{
var content = new RequestUrlEncodedContent("utf-8"); //TODO
foreach (var field in bindingContext.FormFields)
{
content.AddField(field);
}
request.Content = content;
}
else if (bindingContext.Body != null)
{
request.Content = bindingContext.Body;
}
foreach (var header in bindingContext.Headers)
{
request.AddHeader(header);
}
foreach (var segment in bindingContext.Path)
{
request.AddRouteSegment(segment);
}
foreach (var query in bindingContext.Queries)
{
request.AddQuery(query);
}
return(request);
}
internal protected virtual void PaintFinish(Graphics gr, IBindingData data)
{
}
internal protected virtual void Paint(Graphics gr, IBindingData data, Rectangle rcArea)
{
}
internal protected virtual void PaintStart(Graphics gr, IBindingData data)
{
}
public void Remove(IBindingData bd)
{
lst.Remove(bd);
UpdateCount();
}
public void Insert(int index, IBindingData bd)
{
lst.Insert(index, bd);
UpdateCount();
}
public void Add(IBindingData bd)
{
lst.Add(bd);
UpdateCount();
}
/// <inheritdoc />
public bool TryGetBindingData(Type interfaceType, out IBindingData bindingData)
{
GuardNotDisposingOrDisposed();
Guard.RequireNotNull <ArgumentNullException>(interfaceType, $"Invalid '{nameof(interfaceType)}'.");
return(m_InterfaceTypeToBindingDataMap.TryGetValue(interfaceType, out bindingData));
}
protected override void InternalPaintStart(Graphics grChart, IBindingData data)
{
pointLocation = new List <ItemPointInfo>();
}
protected override void InternalPaintChart(Graphics grChart,
IBindingData data, Rectangle rcArea,
ref double xAxisBetweenTextSpace, ref double xAxisTextWidth
)
{
bool bR2L = Parent.Chart.IsRTL();
//Draw lines and points
if ((int)rcChartDrawArea.Height > 0 && (int)rcChartDrawArea.Width > 0)
{
double maxminHeight = (double)(rcChartDrawArea.Height / (MaxInTopOfChartArea - MinInBottomOfChartArea));
double maxOfValueInX = data.ColumnValue(data.ColumnCount - 1); //Use in ColumnScaling mode
double xScale = 1;
if (!ColumnScaling)
{
if (SizingModeLabel == SizingModeLabel.Fit ||
SizingModeLabel == SizingModeLabel.FitIfLarge)
{
double x = 0;
x += data.ColumnCount * nWidthColumn;
xScale = rcChartDrawArea.Width / x;
}
if (SizingModeLabel == SizingModeLabel.FitIfLarge && xScale > 1)
{
xScale = 1;
}
xAxisBetweenTextSpace = 0;
xAxisTextWidth = nWidthColumn * xScale;
}
else
{
double x = 0;
x = maxOfValueInX * nWidthColumn;
xScale = rcChartDrawArea.Width / x;
xAxisBetweenTextSpace = 0;
xAxisTextWidth = nWidthColumn * xScale;
}
Color[] colLineInner = new Color[Parent.Chart.Colors.Length];
for (int i = 0; i < colLineInner.Length; i++)
{
colLineInner[i] = Parent.Chart.Colors[i];
}
if (ColorOverTransparency && data.RowCount > 1)
{
for (int i = 0; i < colLineInner.Length && i < data.RowCount; i++)
{
int minTransparency = 128;
if (data.RowCount > 3)
{
minTransparency = 64;
}
double def = 255 - minTransparency;
def /= (data.RowCount - 1);
double ri = 255 - def * i;
colLineInner[i] = Color.FromArgb((byte)ri, colLineInner[i].R, colLineInner[i].G, colLineInner[i].B);
}
}
Brush[] brPoint = new Brush[colLineInner.Length];
Pen[] penLine = new Pen[colLineInner.Length];
for (int i = 0; i < colLineInner.Length; i++)
{
brPoint[i] = new SolidBrush(colLineInner[i]);
penLine[i] = new Pen(colLineInner[i], nWidthLine)
{
LineJoin = LineJoin.Bevel //If use default (Miter) may be infringe
};
}
double nWidthColumnWithScale = (nWidthColumn * xScale);
RectangleF rcChartDrawArea2 = new RectangleF(
rcChartDrawArea.Left - nDiagonalPoint,
rcChartDrawArea.Top - nDiagonalPoint,
rcChartDrawArea.Width + nDiagonalPoint * 2,
rcChartDrawArea.Height + nDiagonalPoint * 2
);
for (int rowIndex = 0; rowIndex < data.RowCount; rowIndex++)
{
drawAllDataField = true;
double xDraw = 0;
int curConntOfPointLocation = pointLocation.Count;
List <PointF> lst = new List <PointF>();
List <List <PointF> > lstLines = new List <List <PointF> >();
int columnCount = data.ColumnCount;
int columnCount2 = columnCount / 2;
for (int colIndex = 0; colIndex < columnCount; colIndex++)
{
if (!drawAllDataField)
{
break;
}
#region Calculate points
if (ColumnScaling)
{
xDraw = data.ColumnValue(colIndex) * nWidthColumnWithScale + xAxisBetweenTextSpace;
}
double d = data.ValueDouble(rowIndex, colIndex);
bool isOverflow = false;
double yDrawCenterOfPoint = ((d - MinInBottomOfChartArea) * maxminHeight);
if (d > MaxInTopOfChartArea)
{
isOverflow = true;
d = MaxInTopOfChartArea;
yDrawCenterOfPoint = ((d - MinInBottomOfChartArea) * maxminHeight);
}
if (d < MinInBottomOfChartArea)
{
isOverflow = true;
d = MinInBottomOfChartArea;
yDrawCenterOfPoint = ((d - MinInBottomOfChartArea) * maxminHeight);
}
yDrawCenterOfPoint = rcChartDrawArea.Bottom - yDrawCenterOfPoint;
RectangleF rcPoint;
double xDrawCenterOfPoint = 0;
if (bR2L)
{
xDrawCenterOfPoint = rcChartDrawArea.Right - xDraw;
if (!ColumnScaling)//In ColumnScaling is ignore
{
xDrawCenterOfPoint -= nWidthColumnWithScale / 2;
}
}
else
{
xDrawCenterOfPoint = xDraw + rcChartDrawArea.Left;
if (!ColumnScaling)//In ColumnScaling is ignore
{
xDrawCenterOfPoint += nWidthColumnWithScale / 2;
}
}
rcPoint = new RectangleF(
(float)xDrawCenterOfPoint - nDiagonalPoint,
(float)yDrawCenterOfPoint - nDiagonalPoint,
nDiagonalPoint * 2,
nDiagonalPoint * 2);
PointF center = new PointF(
(float)xDrawCenterOfPoint,
(float)yDrawCenterOfPoint);
if (rcChartDrawArea2.Contains(center))
{
ItemPointInfo item = new ItemPointInfo
{
Rect = rcPoint,
Center = center
};
bool bValidValue = data.Valid(rowIndex, colIndex);
if (bValidValue)
{
lst.Add(item.Center);
}
else
{
if (lst.Count > 0)
{
lstLines.Add(lst);
lst = new List <PointF>();
}
}
item.IsOverflow = isOverflow;
item.ColIndex = colIndex;
item.RowIndex = rowIndex;
pointLocation.Add(item);
}
else
{
if (pointLocation.Count > 0 &&
curConntOfPointLocation != pointLocation.Count)
{//If Point is Out,Draw line that is seen
ItemPointInfo item = pointLocation[pointLocation.Count - 1];
bool bValidValue = data.Valid(rowIndex, colIndex);
if (bValidValue)
{
PointF centerBeginPaint = new PointF();
float m = (center.X - item.Center.X);
if (m == 0f)
{
centerBeginPaint.X = center.X;
//Exactly : center.Y != item.center.Y
if (center.Y < item.Center.Y)
{
centerBeginPaint.Y = rcChartDrawArea2.Bottom;
}
else
{
centerBeginPaint.Y = rcChartDrawArea2.Top;
}
}
else
{
float x = (bR2L ? rcChartDrawArea2.Left : rcChartDrawArea2.Right);
m =
(center.Y - item.Center.Y) /
m;
centerBeginPaint.X = x;
centerBeginPaint.Y = m * (x - center.X) + center.Y;
}
lst.Add(centerBeginPaint);
}
}
drawAllDataField = false;
break;
}
if (!ColumnScaling)
{
xDraw += nWidthColumnWithScale;
}
#endregion
}
if (lst.Count > 0)
{
lstLines.Add(lst);
lst = null;
}
Graphics gr = grChart;
//Draw Lines
if (layoutMode != LayoutMode.Point)
{
foreach (List <PointF> lst2 in lstLines)
{
if (lst2.Count > 1)
{
gr.DrawLines(penLine[rowIndex % colLineInner.Length], lst2.ToArray());
}
}
}
//Draw Points
if (layoutMode != LayoutMode.Line)
{
for (int i = curConntOfPointLocation; i < pointLocation.Count; i++)
{
ItemPointInfo item = pointLocation[i];
bool bValidValue = data.Valid(item.RowIndex, item.ColIndex);
if (!bValidValue)
{
continue; //No need Draw
}
int selectedLineColor = item.RowIndex % colLineInner.Length;
if (pointType == PointType.Square)
{
gr.FillRectangle(brPoint[selectedLineColor], item.Rect);
}
else if (pointType == PointType.Circle)
{
gr.FillEllipse(brPoint[selectedLineColor], item.Rect);
}
}
}
}
for (int i = 0; i < colLineInner.Length; i++)
{
brPoint[i].Dispose();
penLine[i].Dispose();
}
}
}
protected override void InternalPaintFinish(Graphics grChart, IBindingData data)
{
}
protected override void InternalPaintChart(Graphics grChart,
IBindingData data, Rectangle rcArea,
ref double xAxisBetweenTextSpace, ref double xAxisTextWidth
)
{
bool bR2L = Parent.Chart.IsRTL();
Pen penLine = new Pen(colBorderOfBar, nWidthBorderOfBarLine);
//Draw bars
if ((int)rcChartDrawArea.Height > 0 && (int)rcChartDrawArea.Width > 0)
{
int xDraw = nGapColumns;
double maxminHeight = (double)(rcChartDrawArea.Height / (MaxInTopOfChartArea - MinInBottomOfChartArea));
double xScale = 1;
if (SizingModeLabel == SizingModeLabel.Fit ||
SizingModeLabel == SizingModeLabel.FitIfLarge)
{
int x = xDraw;
x += data.ColumnCount * data.RowCount * nWidthBar;
x += nGapBarOfColumn * (data.RowCount - 1) * data.ColumnCount;
x += nGapColumns * (data.ColumnCount - 1);
x += nGapBarOfColumn; //For space end Axis and last bar
xScale = rcChartDrawArea.Width / (double)x;
}
if (SizingModeLabel == SizingModeLabel.FitIfLarge && xScale > 1)
{
xScale = 1;
}
xAxisBetweenTextSpace = nGapColumns * xScale;
xAxisTextWidth = data.RowCount * nWidthBar +
(data.RowCount - 1) * nGapBarOfColumn;
xAxisTextWidth *= xScale;
Color[] colBarInner = Parent.Chart.Colors;
Brush[] brBar = new Brush[colBarInner.Length];
for (int i = 0; i < colBarInner.Length; i++)
{
brBar[i] = new SolidBrush(colBarInner[i]);
}
int nWidthBarWithScale = (int)(nWidthBar * xScale);
for (int colIndex = 0; colIndex < data.ColumnCount; colIndex++)
{
if (!drawAllDataField)
{
break;
}
#region Draw bars
int selectedBarColor = 0;
for (int rowIndex = 0; rowIndex < data.RowCount; rowIndex++)
{
double d = data.ValueDouble(rowIndex, colIndex);
bool isOverflow = false;
if (d > 0 && d > MaxInTopOfChartArea)
{
isOverflow = true;
d = MaxInTopOfChartArea;
}
if (d < 0 && d < MinInBottomOfChartArea)
{
isOverflow = true;
d = MinInBottomOfChartArea;
}
int yMustDraw = (int)(d * maxminHeight);
if (yMustDraw == 0)
{
yMustDraw = nWidthBorderOfBarLine;
}
Rectangle rcDraw;
int xDraw2 = 0;
if (bR2L)
{
xDraw2 = (int)rcChartDrawArea.Right - (int)(xDraw * xScale) - nWidthBarWithScale;
}
else
{
xDraw2 = (int)(xDraw * xScale) + (int)rcChartDrawArea.Left;
}
if (yMustDraw >= 0)
{
rcDraw = new Rectangle(
xDraw2, AxisFromTop - yMustDraw,
nWidthBarWithScale, yMustDraw);
}
else
{
rcDraw = new Rectangle(
xDraw2, AxisFromTop,
nWidthBarWithScale, -yMustDraw);
}
if (rcChartDrawArea.Contains(rcDraw))
{
bool bValidValue = data.Valid(rowIndex, colIndex);
if (bValidValue)
{
grChart.FillRectangle(brBar[selectedBarColor], rcDraw);
}
ItemDrawInfo item = new ItemDrawInfo
{
Rect = rcDraw,
IsOverflow = isOverflow,
ColIndex = colIndex,
RowIndex = rowIndex
};
barLocation.Add(item);
if (bValidValue)
{
if (nWidthBorderOfBarLine > 0 || d == 0)
{
grChart.DrawRectangle(penLine, rcDraw);
}
if (isOverflow && rcDraw.Height > nWidthBorderOfBarLine * 2)
{
if (d > 0)
{
grChart.DrawLine(penLine,
rcDraw.Left, rcDraw.Top - nWidthBorderOfBarLine,
rcDraw.Right, rcDraw.Top - nWidthBorderOfBarLine);
}
else if (d < 0)
{
grChart.DrawLine(penLine,
rcDraw.Left, rcDraw.Bottom + nWidthBorderOfBarLine,
rcDraw.Right, rcDraw.Bottom + nWidthBorderOfBarLine);
}
}
}
}
else
{
drawAllDataField = false;
break;
}
xDraw += (nWidthBar + nGapBarOfColumn);
selectedBarColor++;
selectedBarColor %= brBar.Length;
}
#endregion
xDraw -= nGapBarOfColumn;
xDraw += nGapColumns;
}
for (int i = 0; i < colBarInner.Length; i++)
{
brBar[i].Dispose();
}
}
penLine.Dispose();
}
internal protected BindingDataLinearMap(IBindingData bindData)
: this(bindData, 1, 0)
{
}
