public PointF ToPointF(ObjectPoint op)
{
FormulaChart backChart = this.Manager.Canvas.BackChart;
if (backChart != null)
{
return(backChart.GetPointAt(this.AreaName, op.X, null, op.Y));
}
return(PointF.Empty);
}
/// <summary>
/// Convert ObjectPoint to PointF
/// </summary>
/// <param name="op"></param>
/// <returns></returns>
public PointF ToPointF(ObjectPoint op)
{
FormulaChart fc = Manager.Canvas.Chart;
if (fc != null)
{
return(fc.GetPointAt(AreaName, op.X, null, op.Y));
}
return(PointF.Empty);
}
public void InitLine3()
{
Num = 4;
InitPoints = new PointF[]{
new PointF(0,0),
new PointF(1,3),
new PointF(2,1),
new PointF(3,5),
};
ControlPoints = new ObjectPoint[Num];
}
public ObjectManager(IObjectCanvas Canvas, PropertyGrid propertyGrid, ObjectToolPanel ToolPanel)
{
this.StartPoint = ObjectPoint.Empty;
this.EndPoint = ObjectPoint.Empty;
this.objects = new Easychart.Finance.Objects.ObjectCollection();
LoadSettings(ToolPanel);
this.SetHandler(Canvas, propertyGrid, ToolPanel);
if (ToolPanel != null)
{
ToolPanel.LoadObjectTool();
}
}
public void InitLine4()
{
Num = 5;
InitPoints = new PointF[]{
new PointF(0,0),
new PointF(1,2),
new PointF(2,0),
new PointF(3,2),
new PointF(4,0),
};
ControlPoints = new ObjectPoint[Num];
}
private void DesignerControl_MouseDown(object sender, MouseEventArgs e)
{
FormulaArea fa = null;
BaseObject objectAt;
this.StartPoint = this.GetValueFromPos((float)e.X, (float)e.Y, ref fa);
this.SaveChartControlSetting();
if (this.ObjectType == null)
{
this.SelectedObject = null;
if (e.Button == MouseButtons.Left)
{
int controlPointIndex = this.GetPointIndex(e.X, e.Y, out objectAt);
if (objectAt == null)
{
objectAt = this.GetObjectAt(e.X, e.Y);
}
if (objectAt != null)
{
this.SelectedObject = objectAt;
this.DragObject = new ObjectDragging(new PointF((float)e.X, (float)e.Y), controlPointIndex, objectAt);
this.Designer.Invalidate(objectAt.GetRegion());
objectAt.InMove = true;
}
}
}
else if (e.Button == MouseButtons.Right)
{
this.objects.Remove(this.DragObject.Object);
this.DragObjectFinished();
}
else if (this.ObjectSteps == 0)
{
objectAt = this.ObjectType.Invoke();
objectAt.AreaName = fa.Name;
objectAt.Area = fa;
objectAt.InSetup = true;
objectAt.InMove = true;
if (this.AfterCreateStart != null)
{
this.AfterCreateStart(this, objectAt);
}
objectAt.SetObjectManager(this);
for (int i = 0; i < objectAt.ControlPointNum; i++)
{
objectAt.ControlPoints[i] = this.StartPoint;
}
this.objects.Add(objectAt);
this.SelectedObject = objectAt;
this.DragObject = new ObjectDragging(new PointF((float)e.X, (float)e.Y), ((this.ObjectSteps + objectAt.InitNum) > 1) ? 1 : 0, objectAt);
}
this.DragMemBmp = null;
}
public void InitLine5()
{
Num = 6;
InitPoints = new PointF[]{
new PointF(0,0),
new PointF(1,3),
new PointF(2,1),
new PointF(3,5),
new PointF(4,4),
new PointF(5,7),
};
ControlPoints = new ObjectPoint[Num];
}
public override void CalcPoint()
{
SetSnapPrice(snap);
PointF p1 = ToPointF(ControlPoints[0]);
PointF p2 = ToPointF(ControlPoints[1]);
pfStart = new PointF[split.Length];
pfEnd = new PointF[split.Length];
ObjectPoint op = new ObjectPoint(ControlPoints[0].X, 0);
for (int i = 0; i < split.Length; i++)
{
op.Y = GetPrice(i);
PointF p = ToPointF(op);
pfStart[i] = new PointF(p1.X, p.Y);
pfEnd[i] = new PointF(p2.X, p.Y);
}
OpenStartEnd(openStart, openEnd);
}
public override void CalcPoint()
{
base.SetSnapPrice(this.snap);
PointF tf = base.ToPointF(base.ControlPoints[0]);
PointF tf2 = base.ToPointF(base.ControlPoints[1]);
double y = base.ControlPoints[0].Y;
double num2 = base.ControlPoints[1].Y;
base.pfStart = new PointF[this.split.Length];
base.pfEnd = new PointF[this.split.Length];
ObjectPoint op = new ObjectPoint(base.ControlPoints[0].X, 0.0);
for (int i = 0; i < this.split.Length; i++)
{
op.Y = ((num2 - y) * this.split[i]) + y;
PointF tf3 = base.ToPointF(op);
base.pfStart[i] = new PointF(tf.X, tf3.Y);
base.pfEnd[i] = new PointF(tf2.X, tf3.Y);
}
}
public override void CalcPoint()
{
SetSnapPrice(snap);
PointF p1 = ToPointF(ControlPoints[0]);
PointF p2 = ToPointF(ControlPoints[1]);
double A = ControlPoints[0].Y;
double B = ControlPoints[1].Y;
pfStart = new PointF[split.Length];
pfEnd = new PointF[split.Length];
ObjectPoint op = new ObjectPoint(ControlPoints[0].X, 0);
for (int i = 0; i < split.Length; i++)
{
op.Y = (B - A) * split[i] + A;
PointF p = ToPointF(op);
pfStart[i] = new PointF(p1.X, p.Y);
pfEnd[i] = new PointF(p2.X, p.Y);
}
}
/// <summary>
/// Replace format
/// {D:yyyy-MM-dd}
/// {C:f2}
/// {0:f2}
/// </summary>
/// <param name="s"></param>
/// <returns></returns>
public string ReplaceTag(ObjectPoint op, string s)
{
while (true)
{
int i1 = s.IndexOf('{');
int i2 = s.IndexOf('}');
if (i2 > i1)
{
string s1 = s.Substring(i1 + 1, i2 - i1 - 1);
int i = s1.IndexOf(':');
string s3 = "";
string s2 = s1;
if (i > 0)
{
s2 = s1.Substring(0, i);
s3 = s1.Substring(i + 1);
}
FormulaChart BackChart = Manager.Canvas.Chart;
IDataProvider idp = BackChart.DataProvider;
double[] dd = idp["DATE"];
int Bar = BackChart.DateToIndex(op.X);
if (string.Compare(s2, "D") == 0)
{
if (s3 == "")
{
s3 = "yyyy-MM-dd";
}
s2 = BackChart.IndexToDate(Bar).ToString(s3);
}
else
{
FormulaData fd = null;
try
{
i = int.Parse(s2);
if (i < Area.FormulaDataArray.Count)
{
dd = Area.FormulaDataArray[i].Data;
}
}
catch
{
fd = Area.FormulaDataArray[s2];
if (object.Equals(fd, null))
{
foreach (FormulaData f in Area.FormulaDataArray)
{
dd = f[s2];
if (dd != null)
{
break;
}
}
}
else
{
dd = fd.Data;
}
}
if (dd != null && Bar < dd.Length)
{
if (s3 == "")
{
s3 = "f2";
}
s2 = dd[Bar].ToString(s3);
}
else
{
s2 = "NaN";
}
}
s = s.Substring(0, i1) + s2 + s.Substring(i2 + 1);
}
else
{
break;
}
}
return(s);
}
public void Init()
{
ControlPoints = new ObjectPoint[ControlPointNum];
}
public override void CalcPoint()
{
float num3;
this.fd = base.Area.FormulaDataArray[0];
double[] dd = base.Manager.Canvas.BackChart.DataProvider["DATE"];
int index = 0;
int num2 = 1;
if (base.ControlPoints[0].X > base.ControlPoints[1].X)
{
index = 1;
num2 = 0;
}
this.Bar1 = FormulaChart.FindIndex(dd, base.ControlPoints[index].X);
this.Bar2 = FormulaChart.FindIndex(dd, base.ControlPoints[num2].X);
if (this.regressionType != Easychart.Finance.Objects.RegressionType.UpDownTrend)
{
FormulaBase.CalcLinearRegression(this.fd, this.Bar2, this.Bar2 - this.Bar1, out this.A, out this.B);
}
else
{
this.A = base.ControlPoints[index].Y;
this.B = (base.ControlPoints[num2].Y - base.ControlPoints[index].Y) / ((double)(this.Bar2 - this.Bar1));
}
ObjectPoint point = base.ControlPoints[index];
ObjectPoint point2 = base.ControlPoints[num2];
point.Y = this.A;
point2.Y = this.A + (this.B * (this.Bar2 - this.Bar1));
this.scLines.Clear();
if (this.centerLine)
{
this.scLines.Add(point, point2);
}
if (((this.regressionType == Easychart.Finance.Objects.RegressionType.Channel) || (this.regressionType == Easychart.Finance.Objects.RegressionType.AsynChannel)) || (this.regressionType == Easychart.Finance.Objects.RegressionType.UpDownTrend))
{
float num4 = base.CalcDelta(this.fd, this.A, this.B, this.Bar1, this.Bar2, "H", true);
float num5 = base.CalcDelta(this.fd, this.A, this.B, this.Bar1, this.Bar2, "L", false);
if (this.regressionType == Easychart.Finance.Objects.RegressionType.Channel)
{
num3 = Math.Max(Math.Abs(num4), Math.Abs(num5));
}
else
{
num3 = -num4;
}
if (this.upLine)
{
this.AddLine(point, point2, num3);
}
if (this.regressionType != Easychart.Finance.Objects.RegressionType.Channel)
{
num3 = num5;
}
if (this.downLine)
{
this.AddLine(point, point2, -num3);
}
}
else if ((this.regressionType == Easychart.Finance.Objects.RegressionType.StdChannel) || (this.regressionType == Easychart.Finance.Objects.RegressionType.StdErrorChannel))
{
num3 = this.Std(this.regressionType == Easychart.Finance.Objects.RegressionType.StdErrorChannel);
this.AddLine(point, point2, num3);
this.AddLine(point, point2, -num3);
}
base.pfStart = new PointF[this.scLines.Count];
base.pfEnd = new PointF[this.scLines.Count];
for (int i = 0; i < this.scLines.Count; i++)
{
ObjectSegment segment = this.scLines[i];
if (!double.IsNaN(segment.op1.Y) && !double.IsNaN(segment.op2.Y))
{
base.pfStart[i] = base.ToPointF(segment.op1);
base.pfEnd[i] = base.ToPointF(segment.op2);
if (this.openStart)
{
base.ExpandLine(ref base.pfEnd[i], ref base.pfStart[i]);
}
if (this.openEnd)
{
base.ExpandLine(ref base.pfStart[i], ref base.pfEnd[i]);
}
}
else
{
base.pfStart[i] = PointF.Empty;
base.pfEnd[i] = PointF.Empty;
}
}
}
public ObjectBase()
{
ControlPoints = new ObjectPoint[ControlPointNum];
smoothingMode = ObjectSmoothingMode.AntiAlias;
}
/// <summary>
/// Check if (X,Y) in the segment (p1,p2)
/// </summary>
/// <param name="X"></param>
/// <param name="Y"></param>
/// <param name="p1"></param>
/// <param name="p2"></param>
/// <param name="PenWidth"></param>
/// <returns></returns>
public bool InLineSegment(int X, int Y, ObjectPoint p1, ObjectPoint p2, int PenWidth)
{
return(InLineSegment(X, Y, ToPointF(p1), ToPointF(p2), PenWidth));
}
public ObjectSegment(ObjectPoint op1, ObjectPoint op2)
{
this.op1 = op1;
this.op2 = op2;
}
private void AddLine(ObjectPoint op1, ObjectPoint op2, float Delta)
{
op1.Y -= Delta * percentage;
op2.Y -= Delta * percentage;
scLines.Add(op1, op2);
}
private void DesignerControl_MouseDown(object sender, System.Windows.Forms.MouseEventArgs e)
{
Changed = true;
FormulaArea fa = null;
StartPoint = GetValueFromPos(e.X, e.Y, ref fa);
BaseObject bo;
SaveChartControlSetting();
if (ObjectType == null)
{
SelectedObject = null;
if (e.Button == MouseButtons.Left)
{
int PointIndex = GetPointIndex(e.X, e.Y, out bo);
if (bo == null)
{
bo = GetObjectAt(e.X, e.Y);
}
if (bo != null)
{
SelectedObject = bo;
DragObject = new ObjectDragging(new PointF(e.X, e.Y), PointIndex, bo);
Invalidate(bo.GetRegion());
bo.InMove = true;
}
}
}
else
{
if (e.Button == MouseButtons.Right)
{
if (DragObject != null)
{
objects.Remove(DragObject.Object);
}
DragObjectFinished();
}
else
{
if (ObjectSteps == 0)
{
bo = ObjectType.Invoke();
bo.AreaName = fa.Name;
bo.Area = fa;
bo.InSetup = true;
bo.InMove = true;
if (AfterCreateStart != null)
{
AfterCreateStart(this, bo);
}
//ob.SetObjectManager(this);
for (int i = 0; i < bo.ControlPointNum; i++)
{
bo.ControlPoints[i] = StartPoint;
}
AddObject(bo);
//objects.Add(ob);
SelectedObject = bo;
DragObject = new ObjectDragging(new PointF(e.X, e.Y), ObjectSteps + bo.InitNum > 1?1:0, bo);
}
}
}
DragMemBmp = null;
}
public override void CalcPoint()
{
if (Area.FormulaDataArray.Count == 0)
{
return;
}
fd = Area.FormulaDataArray[0];
//IDataProvider idp = Manager.Canvas.BackChart.DataProvider;
//double[] dd = idp["DATE"];
FormulaChart BackChart = Manager.Canvas.Chart;
int i1 = 0;
int i2 = 1;
if (ControlPoints[0].X > ControlPoints[1].X)
{
i1 = 1;
i2 = 0;
}
//Bar1 = FormulaChart.FindIndex(dd,ControlPoints[i1].X);
//Bar2 = FormulaChart.FindIndex(dd,ControlPoints[i2].X);
Bar1 = BackChart.DateToIndex(ControlPoints[i1].X);
Bar2 = BackChart.DateToIndex(ControlPoints[i2].X);
if (regressionType != RegressionType.UpDownTrend)
{
FormulaBase.CalcLinearRegression(fd, Bar2, Bar2 - Bar1, out A, out B);
}
else
{
A = ControlPoints[i1].Y;
B = (ControlPoints[i2].Y - ControlPoints[i1].Y) / (Bar2 - Bar1);
}
ObjectPoint opStart = ControlPoints[i1];
ObjectPoint opEnd = ControlPoints[i2];
opStart.Y = A;
opEnd.Y = A + B * (Bar2 - Bar1);
scLines.Clear();
if (centerLine)
{
scLines.Add(opStart, opEnd);
}
float Delta;
if (regressionType == RegressionType.Channel ||
regressionType == RegressionType.AsynChannel ||
regressionType == RegressionType.UpDownTrend)
{
float dtUp = CalcDelta(fd, A, B, Bar1, Bar2, "H", true);
float dtDown = CalcDelta(fd, A, B, Bar1, Bar2, "L", false);
if (regressionType == RegressionType.Channel)
{
Delta = Math.Max(Math.Abs(dtUp), Math.Abs(dtDown));
}
else
{
Delta = -dtUp;
}
if (upLine)
{
AddLine(opStart, opEnd, Delta);
}
if (regressionType != RegressionType.Channel)
{
Delta = dtDown;
}
if (downLine)
{
AddLine(opStart, opEnd, -Delta);
}
}
else if (regressionType == RegressionType.StdChannel ||
regressionType == RegressionType.StdErrorChannel)
{
Delta = Std(regressionType == RegressionType.StdErrorChannel);
AddLine(opStart, opEnd, Delta);
AddLine(opStart, opEnd, -Delta);
}
pfStart = new PointF[scLines.Count];
pfEnd = new PointF[scLines.Count];
for (int j = 0; j < scLines.Count; j++)
{
ObjectSegment os = scLines[j];
if (!double.IsNaN(os.op1.Y) && !double.IsNaN(os.op2.Y))
{
pfStart[j] = ToPointF(os.op1);
pfEnd[j] = ToPointF(os.op2);
}
else
{
pfStart[j] = PointF.Empty;
pfEnd[j] = PointF.Empty;
}
}
OpenStartEnd(openStart, openEnd);
}
public string ReplaceTag(ObjectPoint op, string s)
{
int num;
Label_0005:
num = s.IndexOf('{');
int index = s.IndexOf('}');
if (index <= num)
{
return(s);
}
string str = s.Substring(num + 1, (index - num) - 1);
int length = str.IndexOf(':');
string format = "";
string strA = str;
if (length > 0)
{
strA = str.Substring(0, length);
format = str.Substring(length + 1);
}
double[] dd = this.Manager.Canvas.BackChart.DataProvider["DATE"];
int num4 = FormulaChart.FindIndex(dd, op.X);
if (num4 >= dd.Length)
{
return(s);
}
if (string.Compare(strA, "D") == 0)
{
if (format == "")
{
format = "yyyy-MM-dd";
}
strA = DateTime.FromOADate(dd[num4]).ToString(format);
goto Label_01BA;
}
FormulaData objA = null;
try
{
length = int.Parse(strA);
if (length < this.Area.FormulaDataArray.Count)
{
dd = this.Area.FormulaDataArray[length].Data;
}
}
catch
{
objA = this.Area.FormulaDataArray[strA];
if (object.Equals(objA, null))
{
foreach (FormulaData data2 in this.Area.FormulaDataArray)
{
dd = data2[strA];
if (dd != null)
{
goto Label_018F;
}
}
}
else
{
dd = objA.Data;
}
}
Label_018F:
if (dd != null)
{
if (format == "")
{
format = "f2";
}
strA = dd[num4].ToString(format);
}
Label_01BA:
s = s.Substring(0, num) + strA + s.Substring(index + 1);
goto Label_0005;
}
public virtual void Add(ObjectPoint op1, ObjectPoint op2)
{
this.Add(new ObjectSegment(op1, op2));
}
private void DesignerControl_MouseDown(object sender, System.Windows.Forms.MouseEventArgs e)
{
FormulaArea fa = null;
StartPoint = GetValueFromPos(e.X, e.Y, ref fa);
ObjectBase ob;
if (Designer is ChartWinControl)
{
SavedShowCrossCursor = (Designer as ChartWinControl).ShowCrossCursor;
SavedShowStatistic = (Designer as ChartWinControl).ShowStatistic;
(Designer as ChartWinControl).ShowCrossCursor = false;
(Designer as ChartWinControl).ShowStatistic = false;
}
if (ObjectType == null)
{
int PointIndex = GetPointIndex(e.X, e.Y, out ob);
if (ob == null)
{
ob = GetObjectAt(e.X, e.Y);
}
if (ob != null)
{
SelectedObject = ob;
DragObject = new DraggingObject(new PointF(e.X, e.Y), PointIndex, ob);
Designer.Invalidate(ob.GetRegion());
Canvas.Dragging = true;
ob.InMove = true;
}
}
else
{
if (e.Button == MouseButtons.Right)
{
objects.Remove(DragObject.Object);
DragObjectFinished();
}
else
{
if (ObjectSteps == 0)
{
ob = ObjectType.Invoke();
ob.AreaName = fa.Name;
ob.Area = fa;
ob.InSetup = true;
ob.InMove = true;
if (AfterCreate != null)
{
AfterCreate(this, ob);
}
ob.SetObjectManager(this);
for (int i = 0; i < ob.ControlPointNum; i++)
{
ob.ControlPoints[i] = StartPoint;
}
objects.Add(ob);
SelectedObject = ob;
DragObject = new DraggingObject(new PointF(e.X, e.Y), ObjectSteps + 1, ob);
Canvas.Dragging = true;
}
else
{
ob = DragObject.Object;
DragObject.ControlPointIndex = ObjectSteps + 1;
}
ObjectSteps++;
if (ObjectSteps == ob.InitNum)
{
DragObjectFinished();
}
}
}
DragMemBmp = null;
}
