public WayPoint(double price, WayPointType wpType)
{
Price = price;
WpType = wpType;
OrdNumb = -1;
PosNumb = -1;
}
public WayPoint(double price, WayPointType wpType)
{
Price = price;
WPType = wpType;
OrdNumb = -1;
PosNumb = -1;
}
/// <summary>
/// Constructor
/// </summary>
public WayPoint(double price, WayPointType wpType, int ordNumb, int posNumb)
{
Price = price;
WpType = wpType;
if (wpType == WayPointType.Open || wpType == WayPointType.High ||
wpType == WayPointType.Low || wpType == WayPointType.Close ||
wpType == WayPointType.None)
{
OrdNumb = -1;
}
else
{
OrdNumb = ordNumb;
}
if (Backtester.PosFromNumb(posNumb).PosDir == PosDirection.None ||
Backtester.PosFromNumb(posNumb).PosDir == PosDirection.Closed &&
wpType != WayPointType.Exit && wpType != WayPointType.Reduce)
{
PosNumb = -1;
}
else
{
PosNumb = posNumb;
}
}
public void Reverse(WayPointType wpt)
{
switch (wpt)
{
case WayPointType.Vendor:
NormalPath.Reverse();
break;
case WayPointType.Repair:
RepairPath.Reverse();
break;
case WayPointType.Normal:
NormalPath.Reverse();
break;
case WayPointType.Ghost:
GhostPath.Reverse();
break;
case WayPointType.Branch:
BranchPath.Reverse();
break;
}
}
public void ClearWaypoints(WayPointType wpType)
{
switch (wpType)
{
case WayPointType.Vendor:
VendorPath.Clear();
CurrentVendorWayPointIndex = 0;
break;
case WayPointType.Repair:
RepairPath.Clear();
CurrentRepairWayPointIndex = 0;
break;
case WayPointType.Normal:
NormalPath.Clear();
CurrentNormalWayPointIndex = 0;
break;
case WayPointType.Ghost:
GhostPath.Clear();
CurrentGhostWayPointIndex = 0;
break;
default:
return;
}
}
/// <summary>
/// Default constructor
/// </summary>
public Way_Point()
{
price = 0;
wpType = WayPointType.None;
ordNumb = -1;
posNumb = -1;
}
/// <summary>
/// Shows the WayPointType as a string.
/// </summary>
public static string WpTypeToString(WayPointType wpType)
{
string output;
switch (wpType)
{
case WayPointType.None:
output = "None";
break;
case WayPointType.Open:
output = "Bar open";
break;
case WayPointType.High:
output = "Bar high";
break;
case WayPointType.Low:
output = "Bar low";
break;
case WayPointType.Close:
output = "Bar close";
break;
case WayPointType.Entry:
output = "Entry point";
break;
case WayPointType.Exit:
output = "Exit point";
break;
case WayPointType.Add:
output = "Adding point";
break;
case WayPointType.Reduce:
output = "Reducing point";
break;
case WayPointType.Reverse:
output = "Reversing point";
break;
case WayPointType.Cancel:
output = "Cancelled order";
break;
default:
output = "Error";
break;
}
return(output);
}
public WayPoint GetNextWayPoint(WayPointType wpType)
{
switch (wpType)
{
case WayPointType.Vendor:
if (VendorNodeCount == 0)
{
return(null);
}
CurrentVendorWayPointIndex++;
if (CurrentVendorWayPointIndex >= VendorNodeCount)
{
CurrentVendorWayPointIndex = 0;
}
return(VendorPath[CurrentVendorWayPointIndex]);
case WayPointType.Repair:
if (RepairNodeCount == 0)
{
return(null);
}
CurrentRepairWayPointIndex++;
if (CurrentRepairWayPointIndex >= RepairNodeCount)
{
CurrentRepairWayPointIndex = 0;
}
return(RepairPath[CurrentRepairWayPointIndex]);
case WayPointType.Normal:
if (NormalNodeCount == 0)
{
return(null);
}
CurrentNormalWayPointIndex++;
if (CurrentNormalWayPointIndex >= NormalNodeCount)
{
CurrentNormalWayPointIndex = 0;
}
return(NormalPath[CurrentNormalWayPointIndex]);
case WayPointType.Ghost:
if (GhostNodeCount == 0)
{
return(null);
}
CurrentGhostWayPointIndex++;
if (CurrentGhostWayPointIndex >= GhostNodeCount)
{
CurrentGhostWayPointIndex = 0;
}
return(GhostPath[CurrentGhostWayPointIndex]);
default:
return(null);
}
}
/// <summary>Returns a Random Waypoint from the Global WaypointList by its type (Ground, Air, Water)</summary>
public static Transform GetWaypoint(WayPointType pointType)
{
if (WayPoints != null && WayPoints.Count > 1)
{
var MWayPoint = WayPoints.Find(item => item.pointType == pointType);
return(MWayPoint ? MWayPoint.WPTransform : null);
}
return(null);
}
/// <summary>
/// Sets a Way Point
/// </summary>
public void SetWayPoint(double price, WayPointType type)
{
if (Positions > 0)
{
WayPoint[WayPoints] = new WayPoint(price, type, Summary.FormOrdNumb, Summary.PosNumb);
}
else
{
WayPoint[WayPoints] = new WayPoint(price, type);
}
WayPoints++;
}
private int[] ArrangeOrderNumbers()
{
var ordNumbers = new int[orders];
int index = 0;
for (int wayPoint = 0; wayPoint < StatsBuffer.WayPoints(selectedBar); wayPoint++)
{
int ordNumb = StatsBuffer.WayPoint(selectedBar, wayPoint).OrdNumb;
WayPointType wpType = StatsBuffer.WayPoint(selectedBar, wayPoint).WpType;
if (ordNumb == -1)
{
continue; // There is no order
}
if (ordNumb < StatsBuffer.OrdNumb(selectedBar, 0))
{
continue; // For a transferred position
}
if (wpType == WayPointType.Add || wpType == WayPointType.Cancel ||
wpType == WayPointType.Entry || wpType == WayPointType.Exit ||
wpType == WayPointType.Reduce || wpType == WayPointType.Reverse)
{
ordNumbers[index] = ordNumb;
index++;
}
}
for (int ord = 0; ord < orders; ord++)
{
int ordNumb = StatsBuffer.OrdNumb(selectedBar, ord);
bool toIncluded = true;
for (int i = 0; i < index; i++)
{
if (ordNumb != ordNumbers[i])
{
continue;
}
toIncluded = false;
break;
}
if (!toIncluded)
{
continue;
}
ordNumbers[index] = ordNumb;
index++;
}
return(ordNumbers);
}
public WayPoint
(Vector2 wayPointOfNortthComand, // up arrow way point
Vector2 wayPointOfSouthComand, // south arrow way point
Vector2 wayPointOfLeftComand, // left arrow way point
Vector2 wayPointOfRightComand, // right arrow way point
WayPointType waypoint
)
{
this.wayPointOfNortthComand = wayPointOfNortthComand;
this.wayPointOfSouthComand = wayPointOfSouthComand;
this.wayPointOfLeftComand = wayPointOfLeftComand;
this.wayPointOfRightComand = wayPointOfRightComand;
this.waypoint = waypoint;
}
/// <summary>
/// Sets a Way Point
/// </summary>
public void SetWayPoint(double price, WayPointType type)
{
if (positions > 0)
{
wayPoint[wayPoints] = new Way_Point(price, type, Summary.FormOrdNumb, Summary.PosNumb);
}
else
{
wayPoint[wayPoints] = new Way_Point(price, type, -1, -1);
}
wayPoints++;
return;
}
/// <summary>
/// Shows the WayPointType as a string.
/// </summary>
public static string WpTypeToString(WayPointType wpType)
{
string output;
switch (wpType)
{
case WayPointType.None:
output = "None";
break;
case WayPointType.Open:
output = "Bar open";
break;
case WayPointType.High:
output = "Bar high";
break;
case WayPointType.Low:
output = "Bar low";
break;
case WayPointType.Close:
output = "Bar close";
break;
case WayPointType.Entry:
output = "Entry point";
break;
case WayPointType.Exit:
output = "Exit point";
break;
case WayPointType.Add:
output = "Adding point";
break;
case WayPointType.Reduce:
output = "Reducing point";
break;
case WayPointType.Reverse:
output = "Reversing point";
break;
case WayPointType.Cancel:
output = "Cancelled order";
break;
default:
output = "Error";
break;
}
return output;
}
/// <summary>
/// Constructor
/// </summary>
public WayPoint(double price, WayPointType wpType, int ordNumb, int posNumb)
{
Price = price;
WPType = wpType;
if (wpType == WayPointType.Open || wpType == WayPointType.High ||
wpType == WayPointType.Low || wpType == WayPointType.Close ||
wpType == WayPointType.None)
OrdNumb = -1;
else
OrdNumb = ordNumb;
if (Backtester.PosFromNumb(posNumb).PosDir == PosDirection.None ||
Backtester.PosFromNumb(posNumb).PosDir == PosDirection.Closed &&
wpType != WayPointType.Exit && wpType != WayPointType.Reduce)
PosNumb = -1;
else
PosNumb = posNumb;
}
private XLSType createRouteServiceRequest(double VDStart, double KDStart, double VDEnd, double KDEnd)
{
XlsDocument xLSDocument = XlsDocument.CreateDocument();
XLSType xLSTypeRequest = xLSDocument.XLS.Append();
// should be added one only
RequestUtil.addXlsHeader(ref xLSTypeRequest);
RequestType requestType = xLSTypeRequest.Request.Append();
requestType.methodName.Value = "DetermineRouteRequest";
DetermineRouteRequestType determineRouteRequest = requestType.DetermineRouteRequest.Append();
RoutePlanType routePlanType = determineRouteRequest.RoutePlan.Append();
RoutePreferenceTypeType routePreferenceTypeType = routePlanType.RoutePreference.Append();
routePreferenceTypeType.Value = "Shortest";
WayPointListType wayPointListType = routePlanType.WayPointList.Append();
// start
WayPointType wayPointTypeStartPoint = wayPointListType.StartPoint.Append();
PositionType positionTypeStartPoint = wayPointTypeStartPoint.Position.Append();
PointType pointTypeStartPoint = positionTypeStartPoint.Point.Append();
DirectPositionType directPositionTypeStartPoint = pointTypeStartPoint.pos.Append();
directPositionTypeStartPoint.Value = VDStart.ToString() + " " + KDStart.ToString();
// end
WayPointType wayPointTypeEndPoint = wayPointListType.EndPoint.Append();
PositionType positionTypeEndPoint = wayPointTypeEndPoint.Position.Append();
PointType pointTypeEndPoint = positionTypeEndPoint.Point.Append();
DirectPositionType directPositionTypeEndPoint = pointTypeEndPoint.pos.Append();
directPositionTypeEndPoint.Value = VDEnd.ToString() + " " + KDEnd.ToString();
determineRouteRequest.RouteGeometryRequest.Append();
// add this if need the text instructions
RouteInstructionsRequestType routeInstructionsRequestType = determineRouteRequest.RouteInstructionsRequest.Append();
routeInstructionsRequestType.format.Value = "text/plain";
return(xLSTypeRequest);
}
/// <summary>
/// Paints panel pnlInfo
/// </summary>
void PnlInfo_Paint(object sender, PaintEventArgs e)
{
// ---------------------------------------------------------------------+
// | Way points description |
// |--------------------------------------------------------------------+
// | Number | Description | Price | Direction | Lots | Position | Order |
// |--------------------------------------------------------------------+
//xp0 xp1 xp2 xp3 xp4 xp5 xp6 xp7
Graphics g = e.Graphics;
g.Clear(LayoutColors.ColorControlBack);
if (!Data.IsData || !Data.IsResult)
{
return;
}
Panel pnl = (Panel)sender;
Brush brush = Brushes.White;
string FF = Data.FF; // Format modifier to print the floats
Size size = new Size(aiX[columns] - aiX[0], infoRowHeight);
StringFormat sf = new StringFormat();
sf.Alignment = StringAlignment.Center;
sf.LineAlignment = StringAlignment.Near;
// Caption background
PointF pntStart = new PointF(0, 0);
SizeF szfCaption = new Size(pnl.ClientSize.Width, 2 * infoRowHeight);
RectangleF rectfCaption = new RectangleF(pntStart, szfCaption);
Data.GradientPaint(g, rectfCaption, LayoutColors.ColorCaptionBack, LayoutColors.DepthCaption);
// Caption Text
StringFormat stringFormatCaption = new StringFormat();
stringFormatCaption.LineAlignment = StringAlignment.Center;
stringFormatCaption.Trimming = StringTrimming.EllipsisCharacter;
stringFormatCaption.FormatFlags = StringFormatFlags.NoWrap;
stringFormatCaption.Alignment = StringAlignment.Near;
string stringCaptionText = Language.T("Way Points Description");
float fCaptionWidth = (float)Math.Min(pnlInfo.ClientSize.Width, aiX[columns] - aiX[0]);
float fCaptionTextWidth = g.MeasureString(stringCaptionText, fontInfo).Width;
float fCaptionTextX = (float)Math.Max((fCaptionWidth - fCaptionTextWidth) / 2f, 0);
PointF pfCaptionText = new PointF(fCaptionTextX, 0);
SizeF sfCaptionText = new SizeF(fCaptionWidth - fCaptionTextX, infoRowHeight);
rectfCaption = new RectangleF(pfCaptionText, sfCaptionText);
// First caption raw
g.DrawString(stringCaptionText, fontInfo, brushCaptionText, rectfCaption, stringFormatCaption);
// Second caption raw
for (int i = 0; i < columns; i++)
{
g.DrawString(asTitles[i], fontInfo, brushCaptionText, (aiX[i] + aiX[i + 1]) / 2, infoRowHeight, sf);
}
brush = new SolidBrush(LayoutColors.ColorControlText);
for (int pnt = 0; pnt < Backtester.WayPoints(bar); pnt++)
{
int y = (pnt + 2) * infoRowHeight;
Point point = new Point(aiX[0], y);
// Even row
if (pnt % 2f != 0)
{
g.FillRectangle(brushEvenRow, new Rectangle(point, size));
}
int positionNumber = Backtester.WayPoint(bar, pnt).PosNumb;
WayPointType wpType = Backtester.WayPoint(bar, pnt).WPType;
PosDirection posDirection = Backtester.PosFromNumb(positionNumber).PosDir;
double posLots = Backtester.PosFromNumb(positionNumber).PosLots;
int ordNumber = Backtester.WayPoint(bar, pnt).OrdNumb;
g.DrawString((pnt + 1).ToString(), fontInfo, brush, (aiX[0] + aiX[1]) / 2, y, sf);
g.DrawString(Language.T(Way_Point.WPTypeToString(wpType)), fontInfo, brush, aiX[1] + 2, y);
g.DrawString(Backtester.WayPoint(bar, pnt).Price.ToString(FF), fontInfo, brush, (aiX[3] + aiX[2]) / 2, y, sf);
if (positionNumber > -1)
{
g.DrawString(Language.T(posDirection.ToString()), fontInfo, brush, (aiX[4] + aiX[3]) / 2, y, sf);
g.DrawString(posLots.ToString(), fontInfo, brush, (aiX[5] + aiX[4]) / 2, y, sf);
g.DrawString((positionNumber + 1).ToString(), fontInfo, brush, (aiX[6] + aiX[5]) / 2, y, sf);
}
if (ordNumber > -1)
{
g.DrawString((ordNumber + 1).ToString(), fontInfo, brush, (aiX[7] + aiX[6]) / 2, y, sf);
}
}
// Vertical lines
Pen penLine = new Pen(LayoutColors.ColorJournalLines);
for (int i = 1; i < columns; i++)
{
g.DrawLine(penLine, aiX[i], 2 * infoRowHeight, aiX[i], ClientSize.Height - border);
}
// Border
Pen penBorder = new Pen(Data.GetGradientColor(LayoutColors.ColorCaptionBack, -LayoutColors.DepthCaption), border);
g.DrawLine(penBorder, 1, 2 * infoRowHeight, 1, pnl.ClientSize.Height);
g.DrawLine(penBorder, pnl.ClientSize.Width - border + 1, 2 * infoRowHeight, pnl.ClientSize.Width - border + 1, pnl.ClientSize.Height);
g.DrawLine(penBorder, 0, pnl.ClientSize.Height - border + 1, pnl.ClientSize.Width, pnl.ClientSize.Height - border + 1);
return;
}
/// <summary>
/// Paints panel pnlChart
/// </summary>
void PnlChart_Paint(object sender, PaintEventArgs e)
{
Graphics g = e.Graphics;
g.Clear(LayoutColors.ColorChartBack);
if (!Data.IsData || !Data.IsResult)
{
return;
}
Panel pnl = (Panel)sender;
Pen penFore = new Pen(LayoutColors.ColorControlText);
string FF = Data.FF; // Format modifier to print the floats
int width = pnl.ClientSize.Width;
Size size = new Size(width, infoRowHeight);
StringFormat sf = new StringFormat();
sf.Alignment = StringAlignment.Center;
sf.LineAlignment = StringAlignment.Near;
// Caption background
PointF pntStart = new PointF(0, 0);
SizeF szfCaption = new Size(width, infoRowHeight);
RectangleF rectfCaption = new RectangleF(pntStart, szfCaption);
Data.GradientPaint(g, rectfCaption, LayoutColors.ColorCaptionBack, LayoutColors.DepthCaption);
// Caption Text
StringFormat stringFormatCaption = new StringFormat();
stringFormatCaption.LineAlignment = StringAlignment.Center;
stringFormatCaption.Trimming = StringTrimming.EllipsisCharacter;
stringFormatCaption.FormatFlags = StringFormatFlags.NoWrap;
stringFormatCaption.Alignment = StringAlignment.Center;
string stringCaptionText = Language.T("Price Route Inside the Bar");
rectfCaption = new RectangleF(border, 0, pnl.ClientSize.Width - 2 * border, infoRowHeight);
g.DrawString(stringCaptionText, fontInfo, brushCaptionText, rectfCaption, stringFormatCaption);
// Paint the panel background
RectangleF rectClient = new RectangleF(0, infoRowHeight, pnl.ClientSize.Width, pnl.Height - infoRowHeight);
Data.GradientPaint(g, rectClient, LayoutColors.ColorChartBack, LayoutColors.DepthControl);
// Paint bar info
RectangleF rectBarInfo = new RectangleF(border, infoRowHeight + 1, pnl.ClientSize.Width - 2 * border, infoRowHeight);
g.DrawString(barInfo, fontInfo, brushGridText, rectBarInfo, stringFormatCaption);
// Searching the min and the max price and volume
width = pnl.ClientSize.Width - 2 * border;
double maxPrice = Data.High[bar];
double minPrice = Data.Low[bar];
int space = 8;
int spcRight = szPrice.Width + 4;
int XLeft = border + space;
int XRight = width - spcRight;
int chartWidth = XRight - XLeft;
int YTop = 2 * infoRowHeight + 6;
int YBottom = pnl.ClientSize.Height - 22;
int barPixels = 28;
int spcLeft = 3;
int x = barPixels + spcLeft;
int pointLeft = x + barPixels + 30;
int pointX = pointLeft;
int pointRight = XRight - 20;
int points = Backtester.WayPoints(bar);
int pointRadius = 3;
// Grid
int iCntLabels = (int)Math.Max((YBottom - YTop) / 30d, 1);
double deltaPoint = (Data.InstrProperties.Digits == 5 || Data.InstrProperties.Digits == 3) ? Data.InstrProperties.Point * 100 : Data.InstrProperties.Point * 10;
double delta = Math.Max(Math.Round((maxPrice - minPrice) / iCntLabels, Data.InstrProperties.Point < 0.001 ? 3 : 1), deltaPoint);
minPrice = Math.Round(minPrice, Data.InstrProperties.Point < 0.001f ? 3 : 1) - Data.InstrProperties.Point * 10;
minPrice -= delta;
maxPrice += delta;
iCntLabels = (int)Math.Ceiling((maxPrice - minPrice) / delta);
maxPrice = minPrice + iCntLabels * delta;
double scaleY = (YBottom - YTop) / (iCntLabels * delta);
int yOpen = (int)(YBottom - (Data.Open[bar] - minPrice) * scaleY);
int yHigh = (int)(YBottom - (Data.High[bar] - minPrice) * scaleY);
int yLow = (int)(YBottom - (Data.Low[bar] - minPrice) * scaleY);
int yClose = (int)(YBottom - (Data.Close[bar] - minPrice) * scaleY);
// Find the price distance
double priceDistance = 0;
for (int point = 1; point < points; point++)
{
priceDistance += Math.Abs(Backtester.WayPoint(bar, point).Price - Backtester.WayPoint(bar, point - 1).Price);
}
double dPriceForAPixel = (pointRight - pointLeft) / priceDistance;
// Points X
int[] aiPointX = new int[points];
aiPointX[0] = pointLeft;
for (int point = 1; point < points - 1; point++)
{
int iDistance = (int)(Math.Abs(Backtester.WayPoint(bar, point).Price - Backtester.WayPoint(bar, point - 1).Price) * dPriceForAPixel);
aiPointX[point] = aiPointX[point - 1] + iDistance;
}
aiPointX[points - 1] = pointRight;
for (int point = 1; point < points - 1; point++)
{
if (aiPointX[point] - aiPointX[point - 1] < barPixels + 1)
{
aiPointX[point] = aiPointX[point - 1] + barPixels + 1;
}
}
for (int point = points - 2; point > 0; point--)
{
if (aiPointX[point + 1] - aiPointX[point] < barPixels + 1)
{
aiPointX[point] = aiPointX[point + 1] - barPixels - 1;
}
}
// Find coordinates of the Way Points
Point[] pntWay = new Point[points];
for (int point = 0; point < points; point++)
{
int pointY = (int)(YBottom - (Backtester.WayPoint(bar, point).Price - minPrice) * scaleY);
pntWay[point] = new Point(aiPointX[point], pointY);
}
// Horizontal grid and Price labels
for (double label = minPrice; label <= maxPrice + Data.InstrProperties.Point; label += delta)
{
int labelY = (int)(YBottom - (label - minPrice) * scaleY);
g.DrawString(label.ToString(Data.FF), Font, brushGridText, XRight, labelY - Font.Height / 2 - 1);
g.DrawLine(penGrid, border + space, labelY, XRight, labelY);
}
// Vertical Grid
g.DrawLine(penGrid, x + barPixels / 2 - 1, YTop, x + barPixels / 2 - 1, YBottom + 2);
for (int point = 0; point < points; point++)
{
Point pt1 = new Point(pntWay[point].X, YTop);
Point pt2 = new Point(pntWay[point].X, YBottom + 2);
Point pt3 = new Point(pntWay[point].X - 5, YBottom + 4);
g.DrawLine(penGrid, pt1, pt2);
g.DrawString((point + 1).ToString(), Font, brushGridText, pt3);
}
// Bar Number
string barNumber = (bar + 1).ToString();
int stringX = x + barPixels / 2 - 1 - g.MeasureString(barNumber, Font).ToSize().Width / 2;
if (Backtester.BackTestEval(bar) == "Ambiguous")
{
g.DrawString(barNumber, Font, brushRed, stringX, YBottom + 4);
}
else
{
g.DrawString(barNumber, Font, brushGridText, stringX, YBottom + 4);
}
// Draw the bar
g.DrawLine(penBarBorder, x + barPixels / 2 - 1, yLow, x + barPixels / 2 - 1, yHigh);
if (yClose < yOpen) // White bar
{
Rectangle rect = new Rectangle(x, yClose, barPixels - 2, yOpen - yClose);
LinearGradientBrush lgBrush = new LinearGradientBrush(rect, colorBarWight1, colorBarWight2, 5f);
g.FillRectangle(lgBrush, rect);
g.DrawRectangle(penBarBorder, x, yClose, barPixels - 2, yOpen - yClose);
}
else if (yClose > yOpen) // Black bar
{
Rectangle rect = new Rectangle(x, yOpen, barPixels - 2, yClose - yOpen);
LinearGradientBrush lgBrush = new LinearGradientBrush(rect, colorBarBlack1, colorBarBlack2, 5f);
g.FillRectangle(lgBrush, rect);
g.DrawRectangle(penBarBorder, x, yOpen, barPixels - 2, yClose - yOpen);
}
else // Cross
{
g.DrawLine(penBarBorder, x, yClose, x + barPixels - 2, yClose);
}
// Draw cancelled orders
for (int orderIndex = 0; orderIndex < Backtester.Orders(bar); orderIndex++)
{
int ordNumber = Backtester.OrdNumb(bar, orderIndex);
Order order = Backtester.OrdFromNumb(ordNumber);
if (order.OrdStatus != OrderStatus.Cancelled)
{
continue;
}
if (order.OrdPrice > Data.High[bar] || order.OrdPrice < Data.Low[bar])
{
continue;
}
int d = barPixels / 2 - 1;
int x1 = x + d;
int x2 = x + barPixels - 2;
int yDeal = (int)(YBottom - (order.OrdPrice - minPrice) * scaleY);
Pen pen = new Pen(LayoutColors.ColorChartGrid, 2);
if (order.OrdDir == OrderDirection.Buy)
{
g.DrawLine(pen, x, yDeal, x1, yDeal);
g.DrawLine(pen, x1, yDeal, x2, yDeal - d);
g.DrawLine(pen, x2 + 1, yDeal - d + 1, x1 + d / 2 + 1, yDeal - d + 1);
g.DrawLine(pen, x2, yDeal - d, x2, yDeal - d / 2);
}
else if (order.OrdDir == OrderDirection.Sell)
{
g.DrawLine(pen, x, yDeal + 1, x1 + 1, yDeal + 1);
g.DrawLine(pen, x1, yDeal, x2, yDeal + d);
g.DrawLine(pen, x1 + d / 2 + 1, yDeal + d, x2, yDeal + d);
g.DrawLine(pen, x2, yDeal + d, x2, yDeal + d / 2 + 1);
}
}
// Draw the deals on the bar
for (int pos = 0; pos < Backtester.Positions(bar); pos++)
{
if (Backtester.PosTransaction(bar, pos) == Transaction.Transfer)
{
continue;
}
int yDeal = (int)(YBottom - (Backtester.PosOrdPrice(bar, pos) - minPrice) * scaleY);
if (Backtester.PosDir(bar, pos) == PosDirection.Long ||
Backtester.PosDir(bar, pos) == PosDirection.Short)
{
int d = barPixels / 2 - 1;
int x1 = x + d;
int x2 = x + barPixels - 2;
if (Backtester.OrdFromNumb(Backtester.PosOrdNumb(bar, pos)).OrdDir == OrderDirection.Buy)
{ // Buy
Pen pen = new Pen(LayoutColors.ColorTradeLong, 2);
g.DrawLine(pen, x, yDeal, x1, yDeal);
g.DrawLine(pen, x1, yDeal, x2, yDeal - d);
g.DrawLine(pen, x2 + 1, yDeal - d + 1, x1 + d / 2 + 1, yDeal - d + 1);
g.DrawLine(pen, x2, yDeal - d, x2, yDeal - d / 2);
}
else
{ // Sell
Pen pen = new Pen(LayoutColors.ColorTradeShort, 2);
g.DrawLine(pen, x, yDeal + 1, x1 + 1, yDeal + 1);
g.DrawLine(pen, x1, yDeal, x2, yDeal + d);
g.DrawLine(pen, x1 + d / 2 + 1, yDeal + d, x2, yDeal + d);
g.DrawLine(pen, x2, yDeal + d, x2, yDeal + d / 2 + 1);
}
}
else if (Backtester.PosDir(bar, pos) == PosDirection.Closed)
{ // Close position
int d = barPixels / 2 - 1;
int x1 = x + d;
int x2 = x + barPixels - 3;
Pen pen = new Pen(LayoutColors.ColorTradeClose, 2);
g.DrawLine(pen, x, yDeal, x1, yDeal);
g.DrawLine(pen, x1, yDeal + d / 2, x2, yDeal - d / 2);
g.DrawLine(pen, x1, yDeal - d / 2, x2, yDeal + d / 2);
}
}
// Draw position lots
for (int point = 0; point < points; point++)
{
int posNumber = Backtester.WayPoint(bar, point).PosNumb;
if (posNumber == -1)
{
continue;
}
double posLots = Backtester.PosFromNumb(posNumber).PosLots;
PosDirection posDirection = Backtester.PosFromNumb(posNumber).PosDir;
WayPointType wpType = Backtester.WayPoint(bar, point).WPType;
int posHight = (int)(Math.Max(posLots * 2, 2));
int posY = YBottom - posHight;
int d = (barPixels - 1) / 2;
x = pntWay[point].X - d;
if (posDirection == PosDirection.Long)
{ // Long
Rectangle rect = new Rectangle(x - 1, posY, barPixels + 1, posHight);
LinearGradientBrush lgBrush = new LinearGradientBrush(rect, colorLongTrade1, colorLongTrade2, 0f);
rect = new Rectangle(x, posY, barPixels - 1, posHight);
g.FillRectangle(lgBrush, rect);
}
else if (posDirection == PosDirection.Short)
{ // Short
Rectangle rect = new Rectangle(x - 1, posY, barPixels + 1, posHight);
LinearGradientBrush lgBrush = new LinearGradientBrush(rect, colorShortTrade1, colorShortTrade2, 0f);
rect = new Rectangle(x, posY, barPixels - 1, posHight);
g.FillRectangle(lgBrush, rect);
}
else if (posDirection == PosDirection.Closed && wpType == WayPointType.Exit)
{ // Closed
Rectangle rect = new Rectangle(x - 1, YBottom - 2, barPixels + 1, 2);
LinearGradientBrush lgBrush = new LinearGradientBrush(rect, colorClosedTrade1, colorClosedTrade2, 0f);
rect = new Rectangle(x, YBottom - 2, barPixels - 1, 2);
g.FillRectangle(lgBrush, rect);
}
}
// Draw the Beziers
for (int point = 1; point < points; point++)
{
Point ptKnot1 = pntWay[point - 1];
Point ptKnot2 = pntWay[point];
int ctrlX1 = (ptKnot1.X + ptKnot2.X) / 2;
int ctrlX2 = (ptKnot1.X + ptKnot2.X) / 2;
int ctrlY1 = ptKnot1.Y;
int ctrlY2 = ptKnot2.Y;
if (point > 1)
{
if (pntWay[point - 2].Y > pntWay[point - 1].Y && pntWay[point - 1].Y > pntWay[point].Y ||
pntWay[point - 2].Y < pntWay[point - 1].Y && pntWay[point - 1].Y < pntWay[point].Y)
{
ctrlY1 = (pntWay[point - 1].Y + pntWay[point].Y) / 2;
}
}
if (point < points - 1)
{
if (pntWay[point - 1].Y > pntWay[point].Y && pntWay[point].Y > pntWay[point + 1].Y ||
pntWay[point - 1].Y < pntWay[point].Y && pntWay[point].Y < pntWay[point + 1].Y)
{
ctrlY2 = (pntWay[point - 1].Y + pntWay[point].Y) / 2;
}
}
if (point == 1)
{
ctrlX1 = ptKnot1.X;
ctrlY1 = ptKnot1.Y;
}
if (point == points - 1)
{
ctrlX2 = ptKnot2.X;
ctrlY2 = ptKnot2.Y;
}
Point ptControl1 = new Point(ctrlX1, ctrlY1);
Point ptControl2 = new Point(ctrlX2, ctrlY2);
g.DrawBezier(penCross, ptKnot1, ptControl1, ptControl2, ptKnot2);
}
// Draw the WayPoints
Brush brushWeyPnt = new SolidBrush(LayoutColors.ColorChartBack);
for (int point = 0; point < points; point++)
{
g.FillEllipse(brushWeyPnt, pntWay[point].X - pointRadius, pntWay[point].Y - pointRadius, 2 * pointRadius, 2 * pointRadius);
g.DrawEllipse(penCross, pntWay[point].X - pointRadius, pntWay[point].Y - pointRadius, 2 * pointRadius, 2 * pointRadius);
}
// Draw the deals on the route
for (int point = 0; point < points; point++)
{
int posNumber = Backtester.WayPoint(bar, point).PosNumb;
int ordNumber = Backtester.WayPoint(bar, point).OrdNumb;
if (posNumber < 0 || ordNumber < 0)
{
continue;
}
PosDirection posDirection = Backtester.PosFromNumb(posNumber).PosDir;
OrderDirection ordDirection = Backtester.OrdFromNumb(ordNumber).OrdDir;
WayPointType wpType = Backtester.WayPoint(bar, point).WPType;
if (Backtester.PosFromNumb(posNumber).Transaction == Transaction.Transfer ||
wpType == WayPointType.Cancel || wpType == WayPointType.None ||
wpType == WayPointType.Open || wpType == WayPointType.High ||
wpType == WayPointType.Low || wpType == WayPointType.Close)
{
continue;
}
int yDeal = pntWay[point].Y;
if (posDirection == PosDirection.Long ||
posDirection == PosDirection.Short)
{
int d = barPixels / 2 - 1;
x = pntWay[point].X - d;
int x1 = pntWay[point].X;
int x2 = x + barPixels - 2;
if (ordDirection == OrderDirection.Buy)
{ // Buy
Pen pen = new Pen(LayoutColors.ColorTradeLong, 2);
g.DrawLine(pen, x, yDeal, x1, yDeal);
g.DrawLine(pen, x1, yDeal, x2, yDeal - d);
g.DrawLine(pen, x2 + 1, yDeal - d + 1, x1 + d / 2 + 1, yDeal - d + 1);
g.DrawLine(pen, x2, yDeal - d, x2, yDeal - d / 2);
}
else
{ // Sell
Pen pen = new Pen(LayoutColors.ColorTradeShort, 2);
g.DrawLine(pen, x, yDeal + 1, x1 + 1, yDeal + 1);
g.DrawLine(pen, x1, yDeal, x2, yDeal + d);
g.DrawLine(pen, x1 + d / 2 + 1, yDeal + d, x2, yDeal + d);
g.DrawLine(pen, x2, yDeal + d, x2, yDeal + d / 2 + 1);
}
}
else if (posDirection == PosDirection.Closed)
{ // Close position
int d = barPixels / 2 - 1;
x = pntWay[point].X - d;
int x1 = pntWay[point].X;
int x2 = x + barPixels - 3;
Pen pen = new Pen(LayoutColors.ColorTradeClose, 2);
g.DrawLine(pen, x, yDeal, x1, yDeal);
g.DrawLine(pen, x1, yDeal + d / 2, x2, yDeal - d / 2);
g.DrawLine(pen, x1, yDeal - d / 2, x2, yDeal + d / 2);
}
}
// Coordinate axes
g.DrawLine(penAxes, XLeft, YTop - 4, XLeft, YBottom); // Vertical left line
g.DrawLine(penAxes, XLeft, YBottom, XRight, YBottom);
// Border
Pen penBorder = new Pen(Data.GetGradientColor(LayoutColors.ColorCaptionBack, -LayoutColors.DepthCaption), border);
g.DrawLine(penBorder, 1, infoRowHeight, 1, pnl.ClientSize.Height);
g.DrawLine(penBorder, pnl.ClientSize.Width - border + 1, infoRowHeight, pnl.ClientSize.Width - border + 1, pnl.ClientSize.Height);
g.DrawLine(penBorder, 0, pnl.ClientSize.Height - border + 1, pnl.ClientSize.Width, pnl.ClientSize.Height - border + 1);
}
/// <summary>
/// Sets a Way Point
/// </summary>
public void SetWayPoint(double price, WayPointType type)
{
if (positions > 0)
wayPoint[wayPoints] = new Way_Point(price, type, Summary.FormOrdNumb, Summary.PosNumb);
else
wayPoint[wayPoints] = new Way_Point(price, type, -1, -1);
wayPoints++;
return;
}
/// <summary>
/// Paints panel pnlChart
/// </summary>
private void PnlChartPaint(object sender, PaintEventArgs e)
{
Graphics g = e.Graphics;
g.Clear(LayoutColors.ColorChartBack);
if (!Data.IsData || !Data.IsResult)
{
return;
}
var pnl = (Panel)sender;
int width = pnl.ClientSize.Width;
// Caption background
var pntStart = new PointF(0, 0);
SizeF szfCaption = new Size(width, _infoRowHeight);
var rectfCaption = new RectangleF(pntStart, szfCaption);
Data.GradientPaint(g, rectfCaption, LayoutColors.ColorCaptionBack, LayoutColors.DepthCaption);
// Caption Text
var stringFormat = new StringFormat
{
LineAlignment = StringAlignment.Center,
Trimming = StringTrimming.EllipsisCharacter,
FormatFlags = StringFormatFlags.NoWrap,
Alignment = StringAlignment.Center
};
string stringCaptionText = Language.T("Price Route Inside the Bar");
rectfCaption = new RectangleF(Border, 0, pnl.ClientSize.Width - 2 * Border, _infoRowHeight);
g.DrawString(stringCaptionText, _fontInfo, _brushCaptionText, rectfCaption, stringFormat);
// Paint the panel background
var rectClient = new RectangleF(0, _infoRowHeight, pnl.ClientSize.Width, pnl.Height - _infoRowHeight);
Data.GradientPaint(g, rectClient, LayoutColors.ColorChartBack, LayoutColors.DepthControl);
// Paint bar info
var rectBarInfo = new RectangleF(Border, _infoRowHeight + 1, pnl.ClientSize.Width - 2 * Border, _infoRowHeight);
g.DrawString(_barInfo, _fontInfo, _brushGridText, rectBarInfo, stringFormat);
// Searching the min and the max price and volume
width = pnl.ClientSize.Width - 2 * Border;
double maxPrice = Data.High[_barCurrent];
double minPrice = Data.Low[_barCurrent];
const int space = 8;
int spcRight = _szPrice.Width + 4;
const int xLeft = Border + space;
int xRight = width - spcRight;
int yTop = 2 * _infoRowHeight + 6;
int yBottom = pnl.ClientSize.Height - 22;
int barPixels = _maxWayPoints < 10 ? 28 : _maxWayPoints < 15 ? 24 : 20;
const int spcLeft = 3;
int x = barPixels + spcLeft;
int pointLeft = x + barPixels + 30;
int pointRight = xRight - 20;
int points = Backtester.WayPoints(_barCurrent);
const int pointRadius = 3;
// Grid
var iCntLabels = (int)Math.Max((yBottom - yTop) / 30d, 1);
double deltaPoint = (Data.InstrProperties.Digits == 5 || Data.InstrProperties.Digits == 3)
? Data.InstrProperties.Point * 100
: Data.InstrProperties.Point * 10;
double delta =
Math.Max(Math.Round((maxPrice - minPrice) / iCntLabels, Data.InstrProperties.Point < 0.001 ? 3 : 1),
deltaPoint);
minPrice = Math.Round(minPrice, Data.InstrProperties.Point < 0.001f ? 3 : 1) - Data.InstrProperties.Point * 10;
minPrice -= delta;
maxPrice += delta;
iCntLabels = (int)Math.Ceiling((maxPrice - minPrice) / delta);
maxPrice = minPrice + iCntLabels * delta;
double scaleY = (yBottom - yTop) / (iCntLabels * delta);
var yOpen = (int)(yBottom - (Data.Open[_barCurrent] - minPrice) * scaleY);
var yHigh = (int)(yBottom - (Data.High[_barCurrent] - minPrice) * scaleY);
var yLow = (int)(yBottom - (Data.Low[_barCurrent] - minPrice) * scaleY);
var yClose = (int)(yBottom - (Data.Close[_barCurrent] - minPrice) * scaleY);
// Find the price distance
double priceDistance = 0;
for (int point = 1; point < points; point++)
{
priceDistance +=
Math.Abs(Backtester.WayPoint(_barCurrent, point).Price -
Backtester.WayPoint(_barCurrent, point - 1).Price);
}
double dPriceForAPixel = (pointRight - pointLeft) / priceDistance;
// Points X
var aiPointX = new int[points];
aiPointX[0] = pointLeft;
for (int point = 1; point < points - 1; point++)
{
var iDistance =
(int)
(Math.Abs(Backtester.WayPoint(_barCurrent, point).Price -
Backtester.WayPoint(_barCurrent, point - 1).Price) * dPriceForAPixel);
aiPointX[point] = aiPointX[point - 1] + iDistance;
}
aiPointX[points - 1] = pointRight;
for (int point = 1; point < points - 1; point++)
{
if (aiPointX[point] - aiPointX[point - 1] < barPixels + 1)
{
aiPointX[point] = aiPointX[point - 1] + barPixels + 1;
}
}
for (int point = points - 2; point > 0; point--)
{
if (aiPointX[point + 1] - aiPointX[point] < barPixels + 1)
{
aiPointX[point] = aiPointX[point + 1] - barPixels - 1;
}
}
// Find coordinates of the Way Points
var pntWay = new Point[points];
for (int point = 0; point < points; point++)
{
var pointY = (int)(yBottom - (Backtester.WayPoint(_barCurrent, point).Price - minPrice) * scaleY);
pntWay[point] = new Point(aiPointX[point], pointY);
}
// Horizontal grid and Price labels
for (double label = minPrice; label <= maxPrice + Data.InstrProperties.Point; label += delta)
{
var labelY = (int)(yBottom - (label - minPrice) * scaleY);
g.DrawString(label.ToString(Data.FF), Font, _brushGridText, xRight, labelY - Font.Height / 2 - 1);
g.DrawLine(_penGrid, Border + space, labelY, xRight, labelY);
}
// Vertical Grid
g.DrawLine(_penGrid, x + barPixels / 2 - 1, yTop, x + barPixels / 2 - 1, yBottom + 2);
for (int point = 0; point < points; point++)
{
var pt1 = new Point(pntWay[point].X, yTop);
var pt2 = new Point(pntWay[point].X, yBottom + 2);
var pt3 = new Point(pntWay[point].X - 5, yBottom + 4);
g.DrawLine(_penGrid, pt1, pt2);
g.DrawString((point + 1).ToString(CultureInfo.InvariantCulture), Font, _brushGridText, pt3);
}
// Bar Number
string barNumber = (_barCurrent + 1).ToString(CultureInfo.InvariantCulture);
int stringX = x + barPixels / 2 - 1 - g.MeasureString(barNumber, Font).ToSize().Width / 2;
Brush barBrush = Backtester.BackTestEval(_barCurrent) == BacktestEval.Ambiguous ? _brushRed : _brushGridText;
g.DrawString(barNumber, Font, barBrush, stringX, yBottom + 4);
// Draw the bar
g.DrawLine(_penBarBorder, x + barPixels / 2 - 1, yLow, x + barPixels / 2 - 1, yHigh);
if (yClose < yOpen) // White bar
{
var rect = new Rectangle(x, yClose, barPixels - 2, yOpen - yClose);
var lgBrush = new LinearGradientBrush(rect, _colorBarWight1, _colorBarWight2, 5f);
g.FillRectangle(lgBrush, rect);
g.DrawRectangle(_penBarBorder, x, yClose, barPixels - 2, yOpen - yClose);
}
else if (yClose > yOpen) // Black bar
{
var rect = new Rectangle(x, yOpen, barPixels - 2, yClose - yOpen);
var lgBrush = new LinearGradientBrush(rect, _colorBarBlack1, _colorBarBlack2, 5f);
g.FillRectangle(lgBrush, rect);
g.DrawRectangle(_penBarBorder, x, yOpen, barPixels - 2, yClose - yOpen);
}
else // Cross
{
g.DrawLine(_penBarBorder, x, yClose, x + barPixels - 2, yClose);
}
// Draw cancelled orders
for (int orderIndex = 0; orderIndex < Backtester.Orders(_barCurrent); orderIndex++)
{
int ordNumber = Backtester.OrdNumb(_barCurrent, orderIndex);
Order order = Backtester.OrdFromNumb(ordNumber);
if (order.OrdStatus != OrderStatus.Cancelled)
{
continue;
}
if (order.OrdPrice > Data.High[_barCurrent] || order.OrdPrice < Data.Low[_barCurrent])
{
continue;
}
int d = barPixels / 2 - 1;
int x1 = x + d;
int x2 = x + barPixels - 2;
var yDeal = (int)(yBottom - (order.OrdPrice - minPrice) * scaleY);
var pen = new Pen(LayoutColors.ColorChartGrid, 2);
if (order.OrdDir == OrderDirection.Buy)
{
g.DrawLine(pen, x, yDeal, x1, yDeal);
g.DrawLine(pen, x1, yDeal, x2, yDeal - d);
g.DrawLine(pen, x2 + 1, yDeal - d + 1, x1 + d / 2 + 1, yDeal - d + 1);
g.DrawLine(pen, x2, yDeal - d, x2, yDeal - d / 2);
}
else if (order.OrdDir == OrderDirection.Sell)
{
g.DrawLine(pen, x, yDeal + 1, x1 + 1, yDeal + 1);
g.DrawLine(pen, x1, yDeal, x2, yDeal + d);
g.DrawLine(pen, x1 + d / 2 + 1, yDeal + d, x2, yDeal + d);
g.DrawLine(pen, x2, yDeal + d, x2, yDeal + d / 2 + 1);
}
}
// Draw the deals on the bar
for (int pos = 0; pos < Backtester.Positions(_barCurrent); pos++)
{
if (Backtester.PosTransaction(_barCurrent, pos) == Transaction.Transfer)
{
continue;
}
var yDeal = (int)(yBottom - (Backtester.PosOrdPrice(_barCurrent, pos) - minPrice) * scaleY);
if (Backtester.PosDir(_barCurrent, pos) == PosDirection.Long ||
Backtester.PosDir(_barCurrent, pos) == PosDirection.Short)
{
int d = barPixels / 2 - 1;
int x1 = x + d;
int x2 = x + barPixels - 2;
if (Backtester.OrdFromNumb(Backtester.PosOrdNumb(_barCurrent, pos)).OrdDir == OrderDirection.Buy)
{
// Buy
var pen = new Pen(LayoutColors.ColorTradeLong, 2);
g.DrawLine(pen, x, yDeal, x1, yDeal);
g.DrawLine(pen, x1, yDeal, x2, yDeal - d);
g.DrawLine(pen, x2 + 1, yDeal - d + 1, x1 + d / 2 + 1, yDeal - d + 1);
g.DrawLine(pen, x2, yDeal - d, x2, yDeal - d / 2);
}
else
{
// Sell
var pen = new Pen(LayoutColors.ColorTradeShort, 2);
g.DrawLine(pen, x, yDeal + 1, x1 + 1, yDeal + 1);
g.DrawLine(pen, x1, yDeal, x2, yDeal + d);
g.DrawLine(pen, x1 + d / 2 + 1, yDeal + d, x2, yDeal + d);
g.DrawLine(pen, x2, yDeal + d, x2, yDeal + d / 2 + 1);
}
}
else if (Backtester.PosDir(_barCurrent, pos) == PosDirection.Closed)
{
// Close position
int d = barPixels / 2 - 1;
int x1 = x + d;
int x2 = x + barPixels - 3;
var pen = new Pen(LayoutColors.ColorTradeClose, 2);
g.DrawLine(pen, x, yDeal, x1, yDeal);
g.DrawLine(pen, x1, yDeal + d / 2, x2, yDeal - d / 2);
g.DrawLine(pen, x1, yDeal - d / 2, x2, yDeal + d / 2);
}
}
// Draw position lots
for (int point = 0; point < points; point++)
{
int posNumber = Backtester.WayPoint(_barCurrent, point).PosNumb;
if (posNumber == -1)
{
continue;
}
Position position = Backtester.PosFromNumb(posNumber);
double posLots = position.PosLots;
PosDirection posDirection = position.PosDir;
WayPointType wpType = Backtester.WayPoint(_barCurrent, point).WPType;
var hight = (int)(Math.Max(posLots * 2, 2));
int lenght = barPixels;
int posX = pntWay[point].X - (barPixels - 1) / 2;
int posY = yBottom - hight;
if (point < points - 1)
{
lenght = pntWay[point + 1].X - pntWay[point].X + 1;
}
if (posDirection == PosDirection.Long)
{
// Long
var rect = new Rectangle(posX - 1, posY - 1, lenght, hight + 2);
var lgBrush = new LinearGradientBrush(rect, _colorLongTrade1, _colorLongTrade2,
LinearGradientMode.Vertical);
rect = new Rectangle(posX - 1, posY, lenght, hight);
g.FillRectangle(lgBrush, rect);
}
else if (posDirection == PosDirection.Short)
{
// Short
var rect = new Rectangle(posX - 1, posY - 1, lenght, hight + 2);
var lgBrush = new LinearGradientBrush(rect, _colorShortTrade1, _colorShortTrade2,
LinearGradientMode.Vertical);
rect = new Rectangle(posX - 1, posY, lenght, hight);
g.FillRectangle(lgBrush, rect);
}
else if (posDirection == PosDirection.Closed && wpType == WayPointType.Exit)
{
// Closed
var rect = new Rectangle(posX - 1, yBottom - 2, barPixels + 1, 2);
var lgBrush = new LinearGradientBrush(rect, _colorClosedTrade1, _colorClosedTrade2,
LinearGradientMode.Vertical);
rect = new Rectangle(posX, yBottom - 2, barPixels - 1, 2);
g.FillRectangle(lgBrush, rect);
}
}
// Draw the Beziers
for (int point = 1; point < points; point++)
{
Point ptKnot1 = pntWay[point - 1];
Point ptKnot2 = pntWay[point];
int ctrlX1 = (ptKnot1.X + ptKnot2.X) / 2;
int ctrlX2 = (ptKnot1.X + ptKnot2.X) / 2;
int ctrlY1 = ptKnot1.Y;
int ctrlY2 = ptKnot2.Y;
if (point > 1)
{
if (pntWay[point - 2].Y > pntWay[point - 1].Y && pntWay[point - 1].Y > pntWay[point].Y ||
pntWay[point - 2].Y < pntWay[point - 1].Y && pntWay[point - 1].Y < pntWay[point].Y)
{
ctrlY1 = (pntWay[point - 1].Y + pntWay[point].Y) / 2;
}
}
if (point < points - 1)
{
if (pntWay[point - 1].Y > pntWay[point].Y && pntWay[point].Y > pntWay[point + 1].Y ||
pntWay[point - 1].Y < pntWay[point].Y && pntWay[point].Y < pntWay[point + 1].Y)
{
ctrlY2 = (pntWay[point - 1].Y + pntWay[point].Y) / 2;
}
}
if (point == 1)
{
ctrlX1 = ptKnot1.X;
ctrlY1 = ptKnot1.Y;
}
if (point == points - 1)
{
ctrlX2 = ptKnot2.X;
ctrlY2 = ptKnot2.Y;
}
var ptControl1 = new Point(ctrlX1, ctrlY1);
var ptControl2 = new Point(ctrlX2, ctrlY2);
g.DrawBezier(_penCross, ptKnot1, ptControl1, ptControl2, ptKnot2);
}
// Draw the WayPoints
Brush brushWeyPnt = new SolidBrush(LayoutColors.ColorChartBack);
for (int point = 0; point < points; point++)
{
g.FillEllipse(brushWeyPnt, pntWay[point].X - pointRadius, pntWay[point].Y - pointRadius, 2 * pointRadius,
2 * pointRadius);
g.DrawEllipse(_penCross, pntWay[point].X - pointRadius, pntWay[point].Y - pointRadius, 2 * pointRadius,
2 * pointRadius);
}
// Draw O, H, L, C labels
for (int point = 0; point < points; point++)
{
WayPointType wpType = Backtester.WayPoint(_barCurrent, point).WPType;
if (wpType != WayPointType.Open && wpType != WayPointType.High &&
wpType != WayPointType.Low && wpType != WayPointType.Close)
{
continue;
}
string label = "?";
switch (wpType)
{
case WayPointType.Open:
label = "O";
break;
case WayPointType.High:
label = "H";
break;
case WayPointType.Low:
label = "L";
break;
case WayPointType.Close:
label = "C";
break;
}
int xPoint = pntWay[point].X;
int yPoint = pntWay[point].Y - Font.Height - 3;
var stringFormatLabel = new StringFormat {
Alignment = StringAlignment.Center
};
g.DrawString(label, Font, _brushGridText, xPoint, yPoint, stringFormatLabel);
}
// Draw the deals on the route
for (int point = 0; point < points; point++)
{
int posNumber = Backtester.WayPoint(_barCurrent, point).PosNumb;
int ordNumber = Backtester.WayPoint(_barCurrent, point).OrdNumb;
if (posNumber < 0 || ordNumber < 0)
{
continue;
}
PosDirection posDirection = Backtester.PosFromNumb(posNumber).PosDir;
OrderDirection ordDirection = Backtester.OrdFromNumb(ordNumber).OrdDir;
WayPointType wpType = Backtester.WayPoint(_barCurrent, point).WPType;
if (wpType == WayPointType.None || wpType == WayPointType.Open || wpType == WayPointType.High ||
wpType == WayPointType.Low || wpType == WayPointType.Close)
{
continue;
}
int yDeal = pntWay[point].Y;
if (posDirection == PosDirection.Long || posDirection == PosDirection.Short ||
wpType == WayPointType.Cancel)
{
int d = barPixels / 2 - 1;
x = pntWay[point].X - d;
int x1 = pntWay[point].X;
int x2 = x + barPixels - 2;
if (ordDirection == OrderDirection.Buy)
{
// Buy
var pen = new Pen(LayoutColors.ColorTradeLong, 2);
if (wpType == WayPointType.Cancel)
{
pen = new Pen(LayoutColors.ColorChartGrid, 2);
}
g.DrawLine(pen, x, yDeal, x1, yDeal);
g.DrawLine(pen, x1, yDeal, x2, yDeal - d);
g.DrawLine(pen, x2 + 1, yDeal - d + 1, x1 + d / 2 + 1, yDeal - d + 1);
g.DrawLine(pen, x2, yDeal - d, x2, yDeal - d / 2);
}
else
{
// Sell
var pen = new Pen(LayoutColors.ColorTradeShort, 2);
if (wpType == WayPointType.Cancel)
{
pen = new Pen(LayoutColors.ColorChartGrid, 2);
}
g.DrawLine(pen, x, yDeal + 1, x1 + 1, yDeal + 1);
g.DrawLine(pen, x1, yDeal, x2, yDeal + d);
g.DrawLine(pen, x1 + d / 2 + 1, yDeal + d, x2, yDeal + d);
g.DrawLine(pen, x2, yDeal + d, x2, yDeal + d / 2 + 1);
}
}
if (posDirection == PosDirection.Closed)
{
// Close position
int d = barPixels / 2 - 1;
x = pntWay[point].X - d;
int x1 = pntWay[point].X;
int x2 = x + barPixels - 3;
var pen = new Pen(LayoutColors.ColorTradeClose, 2);
g.DrawLine(pen, x, yDeal, x1, yDeal);
g.DrawLine(pen, x1, yDeal + d / 2, x2, yDeal - d / 2);
g.DrawLine(pen, x1, yDeal - d / 2, x2, yDeal + d / 2);
}
}
// Coordinate axes
g.DrawLine(_penAxes, xLeft, yTop - 4, xLeft, yBottom); // Vertical left line
g.DrawLine(_penAxes, xLeft, yBottom, xRight, yBottom);
// Border
var penBorder = new Pen(Data.GetGradientColor(LayoutColors.ColorCaptionBack, -LayoutColors.DepthCaption),
Border);
g.DrawLine(penBorder, 1, _infoRowHeight, 1, pnl.ClientSize.Height);
g.DrawLine(penBorder, pnl.ClientSize.Width - Border + 1, _infoRowHeight, pnl.ClientSize.Width - Border + 1,
pnl.ClientSize.Height);
g.DrawLine(penBorder, 0, pnl.ClientSize.Height - Border + 1, pnl.ClientSize.Width,
pnl.ClientSize.Height - Border + 1);
}
public WayPoint(WayPointType waypoint)
{
this.waypoint = waypoint;
}
/// <summary>
/// Sets a Way Point
/// </summary>
public void SetWayPoint(double price, WayPointType type)
{
if (Positions > 0)
WayPoint[WayPoints] = new WayPoint(price, type, Summary.FormOrdNumb, Summary.PosNumb);
else
WayPoint[WayPoints] = new WayPoint(price, type);
WayPoints++;
}
public void Reverse(WayPointType wpt)
{
switch (wpt)
{
case WayPointType.Vendor:
NormalPath.Reverse();
break;
case WayPointType.Repair:
RepairPath.Reverse();
break;
case WayPointType.Normal:
NormalPath.Reverse();
break;
case WayPointType.Ghost:
GhostPath.Reverse();
break;
case WayPointType.Branch:
BranchPath.Reverse();
break;
}
}
public WayPoint GetNextWayPoint(WayPointType wpType)
{
switch (wpType)
{
case WayPointType.Vendor:
if (VendorNodeCount == 0)
{
return null;
}
CurrentVendorWayPointIndex++;
if (CurrentVendorWayPointIndex >= VendorNodeCount)
{
CurrentVendorWayPointIndex = 0;
}
return VendorPath[CurrentVendorWayPointIndex];
case WayPointType.Repair:
if (RepairNodeCount == 0)
{
return null;
}
CurrentRepairWayPointIndex++;
if (CurrentRepairWayPointIndex >= RepairNodeCount)
{
CurrentRepairWayPointIndex = 0;
}
return RepairPath[CurrentRepairWayPointIndex];
case WayPointType.Normal:
if (NormalNodeCount == 0)
{
return null;
}
CurrentNormalWayPointIndex++;
if (CurrentNormalWayPointIndex >= NormalNodeCount)
{
CurrentNormalWayPointIndex = 0;
}
return NormalPath[CurrentNormalWayPointIndex];
case WayPointType.Ghost:
if (GhostNodeCount == 0)
{
return null;
}
CurrentGhostWayPointIndex++;
if (CurrentGhostWayPointIndex >= GhostNodeCount)
{
CurrentGhostWayPointIndex = 0;
}
return GhostPath[CurrentGhostWayPointIndex];
default:
return null;
}
}
public void ClearWaypoints(WayPointType wpType)
{
switch (wpType)
{
case WayPointType.Vendor:
VendorPath.Clear();
CurrentVendorWayPointIndex = 0;
break;
case WayPointType.Repair:
RepairPath.Clear();
CurrentRepairWayPointIndex = 0;
break;
case WayPointType.Normal:
NormalPath.Clear();
CurrentNormalWayPointIndex = 0;
break;
case WayPointType.Ghost:
GhostPath.Clear();
CurrentGhostWayPointIndex = 0;
break;
default:
return;
}
}
/// <summary>
/// Updates the journal data from the backtester
/// </summary>
void UpdateJournalData()
{
if (!Data.IsResult)
{
return;
}
Order[] aOrders = new Order[orders];
aiOrderIcons = new Image[orders];
int ordIndex = 0;
for (int point = 0; point < Backtester.WayPoints(selectedBar); point++)
{
int iOrdNumber = Backtester.WayPoint(selectedBar, point).OrdNumb;
WayPointType wpType = Backtester.WayPoint(selectedBar, point).WPType;
if (iOrdNumber == -1)
{
continue; // There is no order
}
if (iOrdNumber < Backtester.OrdNumb(selectedBar, 0))
{
continue; // For a transferred position
}
if (wpType == WayPointType.Add || wpType == WayPointType.Cancel ||
wpType == WayPointType.Entry || wpType == WayPointType.Exit ||
wpType == WayPointType.Reduce || wpType == WayPointType.Reverse)
{
aOrders[ordIndex] = Backtester.OrdFromNumb(iOrdNumber);
ordIndex++;
}
}
for (int ord = 0; ord < orders; ord++)
{
int ordNumber = Backtester.OrdNumb(selectedBar, ord);
bool toIncluded = true;
for (int i = 0; i < ordIndex; i++)
{
if (ordNumber == aOrders[i].OrdNumb)
{
toIncluded = false;
break;
}
}
if (toIncluded)
{
aOrders[ordIndex] = Backtester.OrdFromNumb(ordNumber);
ordIndex++;
}
}
asJournalData = new string[orders, columns];
for (int ord = firstOrd; ord < firstOrd + shownOrd; ord++)
{
int row = ord - firstOrd;
string ordIF = (aOrders[ord].OrdIF > 0 ? (aOrders[ord].OrdIF + 1).ToString() : "-");
string ordPrice2 = (aOrders[ord].OrdPrice2 > 0 ? aOrders[ord].OrdPrice2.ToString(Data.FF) : "-");
asJournalData[row, 0] = (aOrders[ord].OrdNumb + 1).ToString();
asJournalData[row, 1] = Language.T(aOrders[ord].OrdDir.ToString());
asJournalData[row, 2] = Language.T(aOrders[ord].OrdType.ToString());
if (Configs.AccountInMoney)
{
string sOrdAmount = (aOrders[ord].OrdDir == OrderDirection.Sell ? "-" : "") +
(aOrders[ord].OrdLots * Data.InstrProperties.LotSize).ToString();
asJournalData[row, 3] = sOrdAmount;
}
else
{
asJournalData[row, 3] = aOrders[ord].OrdLots.ToString();
}
asJournalData[row, 4] = aOrders[ord].OrdPrice.ToString(Data.FF);
asJournalData[row, 5] = ordPrice2;
asJournalData[row, 6] = Language.T(aOrders[ord].OrdStatus.ToString());
asJournalData[row, 7] = aOrders[ord].OrdNote;
// Icons
aiOrderIcons[row] = aOrders[ord].OrderIcon;
}
return;
}
public WayPoint()
{
Location = new Vector3D(0, 0, 0);
WPType = WayPointType.Normal;
}
public WayPoint(Vector3D location)
{
Location = location;
WPType = WayPointType.Normal;
}
public WayPoint(Vector3D location, WayPointType type)
{
Location = location;
WPType = type;
}
/// <summary>
/// Paints panel pnlInfo
/// </summary>
private void PnlInfoPaint(object sender, PaintEventArgs e)
{
// ---------------------------------------------------------------------+
// | Way points description |
// |--------------------------------------------------------------------+
// | Number | Description | Price | Direction | Lots | Position | Order |
// |--------------------------------------------------------------------+
//xp0 xp1 xp2 xp3 xp4 xp5 xp6 xp7
Graphics g = e.Graphics;
g.Clear(LayoutColors.ColorControlBack);
if (!Data.IsData || !Data.IsResult)
{
return;
}
var pnl = (Panel)sender;
string ff = Data.FF; // Format modifier to print the floats
var size = new Size(_aiX[_columns] - _aiX[0], _infoRowHeight);
var sf = new StringFormat {
Alignment = StringAlignment.Center, LineAlignment = StringAlignment.Near
};
// Caption background
var pntStart = new PointF(0, 0);
SizeF szfCaption = new Size(pnl.ClientSize.Width, 2 * _infoRowHeight);
var rectfCaption = new RectangleF(pntStart, szfCaption);
Data.GradientPaint(g, rectfCaption, LayoutColors.ColorCaptionBack, LayoutColors.DepthCaption);
// Caption Text
var stringFormat = new StringFormat
{
LineAlignment = StringAlignment.Center,
Trimming = StringTrimming.EllipsisCharacter,
FormatFlags = StringFormatFlags.NoWrap,
Alignment = StringAlignment.Near
};
string stringCaptionText = Language.T("Way Points Description");
float captionWidth = Math.Min(_pnlInfo.ClientSize.Width, _aiX[_columns] - _aiX[0]);
float fCaptionTextWidth = g.MeasureString(stringCaptionText, _fontInfo).Width;
float fCaptionTextX = Math.Max((captionWidth - fCaptionTextWidth) / 2f, 0);
var pfCaptionText = new PointF(fCaptionTextX, 0);
var sfCaptionText = new SizeF(captionWidth - fCaptionTextX, _infoRowHeight);
rectfCaption = new RectangleF(pfCaptionText, sfCaptionText);
// First caption raw
g.DrawString(stringCaptionText, _fontInfo, _brushCaptionText, rectfCaption, stringFormat);
// Second caption raw
for (int i = 0; i < _columns; i++)
{
g.DrawString(_asTitles[i], _fontInfo, _brushCaptionText, (_aiX[i] + _aiX[i + 1]) / 2f, _infoRowHeight, sf);
}
Brush brush = new SolidBrush(LayoutColors.ColorControlText);
for (int pnt = 0; pnt < Backtester.WayPoints(_barCurrent); pnt++)
{
int y = (pnt + 2) * _infoRowHeight;
var point = new Point(_aiX[0], y);
// Even row
if (Math.Abs(pnt % 2f - 0) > 0.00001)
{
g.FillRectangle(_brushEvenRow, new Rectangle(point, size));
}
int positionNumber = Backtester.WayPoint(_barCurrent, pnt).PosNumb;
WayPointType wpType = Backtester.WayPoint(_barCurrent, pnt).WPType;
PosDirection posDirection = Backtester.PosFromNumb(positionNumber).PosDir;
double posLots = Backtester.PosFromNumb(positionNumber).PosLots;
int ordNumber = Backtester.WayPoint(_barCurrent, pnt).OrdNumb;
g.DrawString((pnt + 1).ToString(CultureInfo.InvariantCulture), _fontInfo, brush, (_aiX[0] + _aiX[1]) / 2f,
y, sf);
g.DrawString(Language.T(WayPoint.WPTypeToString(wpType)), _fontInfo, brush, _aiX[1] + 2, y);
g.DrawString(Backtester.WayPoint(_barCurrent, pnt).Price.ToString(ff), _fontInfo, brush,
(_aiX[3] + _aiX[2]) / 2f, y, sf);
if (positionNumber > -1)
{
g.DrawString(Language.T(posDirection.ToString()), _fontInfo, brush, (_aiX[4] + _aiX[3]) / 2f, y, sf);
g.DrawString(posLots.ToString(CultureInfo.InvariantCulture), _fontInfo, brush,
(_aiX[5] + _aiX[4]) / 2f, y, sf);
g.DrawString((positionNumber + 1).ToString(CultureInfo.InvariantCulture), _fontInfo, brush,
(_aiX[6] + _aiX[5]) / 2f, y, sf);
}
if (ordNumber > -1)
{
g.DrawString((ordNumber + 1).ToString(CultureInfo.InvariantCulture), _fontInfo, brush,
(_aiX[7] + _aiX[6]) / 2f, y, sf);
}
}
// Vertical lines
var penLine = new Pen(LayoutColors.ColorJournalLines);
for (int i = 1; i < _columns; i++)
{
g.DrawLine(penLine, _aiX[i], 2 * _infoRowHeight, _aiX[i], ClientSize.Height - Border);
}
// Border
var penBorder = new Pen(Data.GetGradientColor(LayoutColors.ColorCaptionBack, -LayoutColors.DepthCaption),
Border);
g.DrawLine(penBorder, 1, 2 * _infoRowHeight, 1, pnl.ClientSize.Height);
g.DrawLine(penBorder, pnl.ClientSize.Width - Border + 1, 2 * _infoRowHeight, pnl.ClientSize.Width - Border + 1,
pnl.ClientSize.Height);
g.DrawLine(penBorder, 0, pnl.ClientSize.Height - Border + 1, pnl.ClientSize.Width,
pnl.ClientSize.Height - Border + 1);
}
/// <summary>
/// Iterates through the waypoints and makes us walk to the next one in the list
/// </summary>
/// <param name="wpType">The type of waypoint we're going to (Normal, Vendor, GraveYard, etc..)</param>
public void WalkToNextWayPoint(WayPointType wpType)
{
WayPoint wp = WayPointManager.Instance.GetNextWayPoint(wpType);
if (wp != null)
{
MoveTo(wp.Location);
}
}