public float StackPoint(IChartPoint point, int seriesStackPosition)
{
var index = unchecked ((int)point.SecondaryValue);
var start = seriesStackPosition == 0 ? 0 : stack[seriesStackPosition - 1][index].End;
var value = point.PrimaryValue;
var si = stack[seriesStackPosition];
if (si.Count < point.SecondaryValue + 1)
{
si.Add(new StackedValue {
Start = start, End = start + value
});
totals.Add(value);
knownMaxLenght++;
}
else
{
si[index] = new StackedValue {
Start = start, End = start + value
};
}
var total = totals[index] + value;
totals[index] = total;
return(total);
}
protected override void SetDefaultPointTransitions(IChartPoint <TVisual, TLabel, TDrawingContext> chartPoint)
{
var visual = chartPoint.Context.Visual;
var chart = chartPoint.Context.Chart;
if (visual == null)
{
throw new Exception("Unable to initialize the point instance.");
}
visual
.TransitionateProperties(
nameof(visual.CenterX),
nameof(visual.CenterY),
nameof(visual.X),
nameof(visual.Y),
nameof(visual.Width),
nameof(visual.Height),
nameof(visual.StartAngle),
nameof(visual.SweepAngle),
nameof(visual.PushOut),
nameof(visual.InnerRadius))
.WithAnimation(animation =>
animation
.WithDuration(chart.AnimationsSpeed)
.WithEasingFunction(chart.EasingFunction));
}
private void OnRemCpEvent(CPLineEvArgs args)
{
int rowIndex = -1;
Tuple <ILineChartPoints, IChartPoint> tagData = new Tuple <ILineChartPoints, IChartPoint>(args.lineCPs, args.cp);
foreach (DataGridViewRow row in list.Rows)
{
if (row.Tag.Equals(tagData))
{
if (tagData.Item2 == cpIgnore)
{
cpIgnore = null;
}
else
{
rowIndex = row.Index;
}
break;
}
}
if (rowIndex >= 0)
{
//tagData.Item1.remCPEvent.On -= OnRemCpEvent;
list.Rows.RemoveAt(rowIndex);
}
}
protected override void SetDefaultPointTransitions(IChartPoint <TVisual, TLabel, TDrawingContext> chartPoint)
{
var visual = chartPoint.Context.Visual;
var chart = chartPoint.Context.Chart;
if (visual == null)
{
throw new Exception("Unable to initialize the point instance.");
}
visual
.TransitionateProperties(
nameof(visual.X),
nameof(visual.Width))
.WithAnimation(animation =>
animation
.WithDuration((long)(chart.AnimationsSpeed.TotalMilliseconds * 1.5))
.WithEasingFunction(elasticFunction));
visual
.TransitionateProperties(
nameof(visual.Y),
nameof(visual.Height))
.WithAnimation(animation =>
animation
.WithDuration(chart.AnimationsSpeed)
.WithEasingFunction(chart.EasingFunction));
}
public StackedValue GetStack(IChartPoint point, int seriesStackPosition)
{
var index = unchecked ((int)point.SecondaryValue);
var p = stack[seriesStackPosition][index];
return(new StackedValue
{
Start = p.Start,
End = p.End
});
}
private ELineCPsStatus UpdateStatus(IChartPoint cp)
{
ELineCPsStatus curStatus = theStatus;
theStatus = (ELineCPsStatus)((int)theStatus | (int)cp.data.status);
if (curStatus != theStatus)
{
lineCPStatusChangedEvent.Fire(new LineCPStatusEvArgs(this));
}
return(theStatus);
}
public bool RemoveChartPoint(IChartPoint chartPnt)
{
bool ret = chartPoints.Remove(chartPnt);
if (ret)
{
chartPnt.cpStatusChangedEvent -= OnCPStatusChanged;
CalcStatus();
remCPEvent.Fire(new CPLineEvArgs(this, chartPnt));
}
return(ret);
}
public bool AddChartPoint(IChartPoint chartPnt)
{
if (GetChartPoint(chartPnt.data.uniqueName) == null)
{
chartPoints.Add(chartPnt);
chartPnt.cpStatusChangedEvent += OnCPStatusChanged;
UpdateStatus(chartPnt);
addCPEvent.Fire(new CPLineEvArgs(this, chartPnt));
return(true);
}
return(false);
}
public bool AddChartPoint(string varName, out IChartPoint chartPnt)
{
chartPnt = null;
IClassElement codeClass = codeClassMethod.GetClass();
CP.Code.IClassVarElement codeElem = codeClass.GetVar(varName);
if (codeElem != null)
{
return(AddChartPoint(codeElem, out chartPnt, false));
}
return(false);
}
private void OnPointMeasured(IChartPoint <RectangleGeometry, LabelGeometry, SkiaSharpDrawingContext> point)
{
var visual = point.Context.Visual;
var delayedFunction = new DelayedFunction(EasingFunctions.BuildCustomElasticOut(1.5f, 0.60f), point);
visual
.TransitionateProperties(
nameof(visual.Y),
nameof(visual.Height))
.WithAnimation(animation =>
animation
.WithDuration(delayedFunction.Speed)
.WithEasingFunction(delayedFunction.Function));
}
public bool SyncChartPoint(ICheckElem checkElem)
{
if (checkElem.exists)
{
IChartPoint chartPnt = null;
AddChartPoint(checkElem.uniqueName, codeClassMethod.GetClass(), out chartPnt, false);
}
else
{
IChartPoint cp = chartPoints.FirstOrDefault((lp) => (lp.data.uniqueName == checkElem.uniqueName));
if (cp != null)
{
RemoveChartPoint(cp);
}
}
return(false);
}
public bool AddChartPoint(CP.Code.IClassVarElement codeElem, out IChartPoint chartPnt, bool checkExistance = true)
{
if (checkExistance)
{
chartPnt = GetChartPoint(codeElem.uniqueName);
if (chartPnt != null)
{
return(false);
}
}
chartPnt = CP.Utils.IClassFactory.GetInstance().CreateCP(codeElem, data);
chartPoints.Add(chartPnt);
chartPnt.cpStatusChangedEvent += OnCPStatusChanged;
UpdateStatus(chartPnt);
addCPEvent.Fire(new CPLineEvArgs(this, chartPnt));
return(true);
}
public DelayedFunction(Func <float, float> baseFunction, IChartPoint point)
{
var visual = point.Context.Visual;
var chart = point.Context.Chart;
var delay = point.Context.Index * 10;
var speed = (float)chart.AnimationsSpeed.TotalMilliseconds + delay;
var d = delay / speed;
Function = p =>
{
if (p <= d)
{
return(0);
}
var p2 = (p - d) / (1 - d);
return(baseFunction(p2));
};
Speed = TimeSpan.FromMilliseconds(speed);
}
private Point GetDisplayPoint(IChartPoint chartPoint)
{
if (VerticalAxis == null || TimeLineSource == null)
{
return(new Point());
}
var ration = (Math.Abs(chartPoint.Value) * VerticalAxis.PointToPixelRatio) / VerticalAxis.MiniTick;
var pointY = chartPoint.Value < 0 ?
VerticalAxis.ZeroPosition + ration :
VerticalAxis.ZeroPosition - ration;
var pointX = TimeLineSource.GetPositionOfMinute(chartPoint.TimeStamp);
// if the point is out of tollerance give it a new Y coordinate
if (Math.Abs(chartPoint.Value) > VerticalAxis.ErrorTolerance)
{
pointY = chartPoint.Value > 0 ?
VerticalAxis.LinesSource.FirstOrDefault().Top - 30 : // bellow the button red line
VerticalAxis.LinesSource.FirstOrDefault().Top + 30; // above the top red line
}
return(new Point(pointX, pointY));
}
private void OnListOnKeyDown(object sender, KeyEventArgs keyEventArgs)
{
switch (keyEventArgs.KeyCode)
{
case Keys.Enter:
break;
case Keys.Delete:
if (list.SelectedRows.Count > 0)
{
DataGridViewRow row = list.SelectedRows[0];
Tuple <ILineChartPoints, IChartPoint> tagData = (Tuple <ILineChartPoints, IChartPoint>)row.Tag;
//tagData.Item1.remCPEvent.On -= OnRemCpEvent;
cpIgnore = tagData.Item2;
if (tagData.Item1.RemoveChartPoint(tagData.Item2))
{
}
//list.Rows.RemoveAt( row.Index );
}
break;
}
}
public bool RemoveChartPoints(string projName)
{
IProjectChartPoints pcp = GetProjectChartPoints(projName);
if (pcp != null)
{
IFileChartPoints fCPs = null;
while ((fCPs = pcp.filePoints.FirstOrDefault()) != null)
{
if (fCPs.linePoints.Count == 0)
{
pcp.filePoints.Remove(fCPs);
}
else
{
ILineChartPoints lCPs = null;
while ((lCPs = fCPs.linePoints.FirstOrDefault()) != null)
{
if (lCPs.chartPoints.Count == 0)
{
fCPs.RemoveLineChartPoints(lCPs);
}
else
{
IChartPoint cp = null;
while ((cp = lCPs.chartPoints.FirstOrDefault()) != null)
{
lCPs.RemoveChartPoint(cp);
}
}
}
}
}
data.projPoints.Remove(pcp);
}
return(true);
}
public override void OnApplyTemplate()
{
base.OnApplyTemplate();
var host = GetTemplateChild("PART_LineHost") as Canvas;
var path = GetTemplateChild("PART_PointsPath") as Path;
if (path == null)
{
return;
}
// switch on the tip for the point!
Observable.FromEventPattern <MouseEventArgs>(path, "PreviewMouseMove")
.Where(_ => SelectedPoint == null)
.Select(eve => eve.EventArgs.GetPosition(host))
.DistinctUntilChanged()
.Subscribe(position =>
SelectedPoint = Points.FirstOrDefault(point => point.DisplayPosition.X + 5 > position.X));
Observable.FromEventPattern <MouseEventArgs>(path, "MouseLeave")
.Where(_ => SelectedPoint != null)
.Subscribe(_ => SelectedPoint = null);
}
public CPStatusEvArgs(IChartPoint _cp)
{
cp = _cp;
}
public static void AddToState(this IChartPoint chartPoint, string state)
{
chartPoint.Context.Series.AddPointToState(chartPoint, state);
}
public static void RemoveFromState(this IChartPoint chartPoint, string state)
{
chartPoint.Context.Series.RemovePointFromState(chartPoint, state);
}
public static void AddToHoverState(this IChartPoint chartPoint)
{
chartPoint.Context.Series.AddPointToState(chartPoint, chartPoint.Context.Series.HoverState);
}
public static void RemoveFromHoverState(this IChartPoint chartPoint)
{
chartPoint.Context.Series.RemovePointFromState(chartPoint, chartPoint.Context.Series.HoverState);
}
protected CPPropsDeSerializator(SerializationInfo info, StreamingContext context)
{
try
{
UInt32 projsCount = info.GetUInt32("projPoints.Count");
for (uint p = 0; p < projsCount; ++p)
{
string projName = info.GetString("projName_" + p.ToString());
Globals.processor.RemoveChartPoints(projName);
UInt32 filesCount = info.GetUInt32("filePoints.Count_" + p.ToString());
if (filesCount > 0)
{
IProjectChartPoints projCPs = Globals.processor.GetProjectChartPoints(projName);
if (projCPs == null)
{
Globals.processor.AddProjectChartPoints(projName, out projCPs);
}
if (projCPs != null)
{
for (uint f = 0; f < filesCount; ++f)
{
string fileName = info.GetString("fileName_" + p.ToString() + f.ToString());
IFileChartPoints fPnts = projCPs.AddFileChartPoints(fileName);
if (fPnts != null)
{
UInt32 linesCount = info.GetUInt32("linePoints.Count_" + p.ToString() + f.ToString());
for (uint l = 0; l < linesCount; ++l)
{
UInt32 lineNum = info.GetUInt32("lineNum_" + p.ToString() + f.ToString() + l.ToString());
UInt32 linePos = info.GetUInt32("linePos_" + p.ToString() + f.ToString() + l.ToString());
ILineChartPoints lPnts = fPnts.AddLineChartPoints((int)lineNum, (int)linePos);
if (lPnts != null)
{
UInt32 cpsCount = info.GetUInt32("cpsPoints.Count_" + p.ToString() + f.ToString() + l.ToString());
for (uint cp = 0; cp < cpsCount; ++cp)
{
IChartPoint chartPnt = null;
string uniqueName = info.GetString("uniqueName_" + p.ToString() + f.ToString() + l.ToString() + cp.ToString());
bool enabled = info.GetBoolean("enabled_" + p.ToString() + f.ToString() + l.ToString() + cp.ToString());
if (lPnts.AddChartPoint(uniqueName, out chartPnt))
{
chartPnt.SetStatus(enabled ? EChartPointStatus.SwitchedOn : EChartPointStatus.SwitchedOff);
}
}
}
if (lPnts.Count == 0)
{
fPnts.RemoveLineChartPoints(lPnts);
}
}
}
}
}
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
public BezierData(IChartPoint <TVisual, TLabel, TDrawingContext> chartPoint)
{
targetPoint = chartPoint;
}
public CPTracker(IChartPoint _cp)
{
cp = _cp;
}
private static double GetAngleInRadian(IChartPoint value)
{
return(Math.PI * (value.Value + 90.0) / 180.0);
}
public TooltipPoint(ISeries series, IChartPoint point)
{
this.series = series;
this.point = point;
}
public CPLineEvArgs(ILineChartPoints _lineCPs, IChartPoint _cp)
{
lineCPs = _lineCPs;
cp = _cp;
}
private static double GetAngleInRadian(IChartPoint value)
{
return Math.PI * (value.Value + 90.0) / 180.0;
}
