public override Cursor GetCursor(ChartControl chartControl, ChartPanel chartPanel, ChartScale chartScale, Point point)
{
if (!IsVisible)
{
return(null);
}
switch (DrawingState)
{
case DrawingState.Building: return(Cursors.Pen);
case DrawingState.Moving: return(IsLocked ? Cursors.No : Cursors.SizeAll);
case DrawingState.Editing:
if (IsLocked)
{
return(Cursors.No);
}
return(editingAnchor == StartAnchor ? Cursors.SizeNESW : Cursors.SizeNWSE);
default:
Point startAnchorPixelPoint = StartAnchor.GetPoint(chartControl, chartPanel, chartScale);
ChartAnchor closest = GetClosestAnchor(chartControl, chartPanel, chartScale, cursorSensitivity, point);
if (closest != null)
{
if (IsLocked)
{
return(Cursors.Arrow);
}
return(closest == StartAnchor ? Cursors.SizeNESW : Cursors.SizeNWSE);
}
// Check the anchor lines for cursor
Point endAnchorPixelPoint = EndAnchor.GetPoint(chartControl, chartPanel, chartScale);
Point extAnchorPixelPoint = ExtensionAnchor.GetPoint(chartControl, chartPanel, chartScale);
Point midAnchorPixelPoint = new Point((endAnchorPixelPoint.X + extAnchorPixelPoint.X) / 2, (endAnchorPixelPoint.Y + extAnchorPixelPoint.Y) / 2);
Vector startToEndVec = endAnchorPixelPoint - startAnchorPixelPoint;
Vector endToExtVec = extAnchorPixelPoint - endAnchorPixelPoint;
Vector startToMidVec = midAnchorPixelPoint - startAnchorPixelPoint;
foreach (Tuple <Point, Point> endPoint in GetAndrewsEndPoints(chartControl, chartScale))
{
Vector andrewVector = endPoint.Item1 - endPoint.Item2;
if (MathHelper.IsPointAlongVector(point, endPoint.Item2, andrewVector, cursorSensitivity))
{
return(IsLocked ? Cursors.Arrow : Cursors.SizeAll);
}
}
return(MathHelper.IsPointAlongVector(point, startAnchorPixelPoint, startToEndVec, cursorSensitivity) ||
MathHelper.IsPointAlongVector(point, endAnchorPixelPoint, endToExtVec, cursorSensitivity) ||
MathHelper.IsPointAlongVector(point, startAnchorPixelPoint, startToMidVec, cursorSensitivity) ?
(IsLocked ? Cursors.Arrow : Cursors.SizeAll) : null);
}
}
public override bool IsVisibleOnChart(ChartControl chartControl, ChartScale chartScale, DateTime firstTimeOnChart, DateTime lastTimeOnChart)
{
// First check any of the actual anchors are visible, we are immediately done
foreach (ChartAnchor anchor in Anchors)
{
if (anchor.IsEditing || anchor.Time >= firstTimeOnChart && anchor.Time <= lastTimeOnChart)
{
return(true);
}
}
// Calculate extensions and see if they extend into our visible times
ChartPanel chartPanel = chartControl.ChartPanels[PanelIndex];
Point anchorStartPoint = StartAnchor.GetPoint(chartControl, chartPanel, chartScale);
Point anchorEndPoint = EndAnchor.GetPoint(chartControl, chartPanel, chartScale);
Point anchorExtensionPoint = ExtensionAnchor.GetPoint(chartControl, chartPanel, chartScale);
Point midPointExtension = new Point((anchorExtensionPoint.X + anchorEndPoint.X) / 2, (anchorExtensionPoint.Y + anchorEndPoint.Y) / 2);
if (CalculationMethod == AndrewsPitchforkCalculationMethod.Schiff)
{
anchorStartPoint = new Point(anchorStartPoint.X, (anchorStartPoint.Y + anchorEndPoint.Y) / 2);
}
else if (CalculationMethod == AndrewsPitchforkCalculationMethod.ModifiedSchiff)
{
anchorStartPoint = new Point((anchorEndPoint.X + anchorStartPoint.X) / 2, (anchorEndPoint.Y + anchorStartPoint.Y) / 2);
}
double totalPriceRange = EndAnchor.Price - ExtensionAnchor.Price;
double startPrice = ExtensionAnchor.Price;
foreach (PriceLevel priceLevel in PriceLevels.Where(pl => pl.IsVisible && pl.Stroke != null))
{
double levelPrice = (startPrice + ((priceLevel.Value / 100) * totalPriceRange));
float pixelY = chartScale.GetYByValue(levelPrice);
float pixelX = anchorExtensionPoint.X > anchorEndPoint.X ?
(float)(anchorExtensionPoint.X - (Math.Abs((anchorEndPoint.X - anchorExtensionPoint.X) * (priceLevel.Value / 100)))) :
(float)(anchorExtensionPoint.X + ((anchorEndPoint.X - anchorExtensionPoint.X) * (priceLevel.Value / 100)));
Point startPoint = new Point(pixelX, pixelY);
Point endPoint = new Point(startPoint.X + (midPointExtension.X - anchorStartPoint.X), startPoint.Y + (midPointExtension.Y - anchorStartPoint.Y));
Point maxLevelPoint = GetExtendedPoint(startPoint, endPoint);
double padding = 5d;
foreach (Point chkPoint in new[] { startPoint, maxLevelPoint, endPoint })
{
if (chkPoint.X >= chartPanel.X - padding && chkPoint.X <= chartPanel.W + chartPanel.X + padding &&
chkPoint.Y >= chartPanel.Y - padding && chkPoint.Y <= chartPanel.Y + chartPanel.H + padding)
{
return(true);
}
}
}
return(false);
}
public override Point[] GetSelectionPoints(ChartControl chartControl, ChartScale chartScale)
{
if (!IsVisible)
{
return(new Point[0]);
}
ChartPanel chartPanel = chartControl.ChartPanels[PanelIndex];
Point startPoint = StartAnchor.GetPoint(chartControl, chartPanel, chartScale);
Point endPoint = EndAnchor.GetPoint(chartControl, chartPanel, chartScale);
Point midPoint = new Point((startPoint.X + endPoint.X) / 2, (startPoint.Y + endPoint.Y) / 2);
Point extPoint = ExtensionAnchor.GetPoint(chartControl, chartPanel, chartScale);
return(new[] { startPoint, midPoint, endPoint, extPoint });
}
private IEnumerable <Tuple <Point, Point> > GetAndrewsEndPoints(ChartControl chartControl, ChartScale chartScale)
{
ChartPanel panel = chartControl.ChartPanels[PanelIndex];
double totalPriceRange = EndAnchor.Price - ExtensionAnchor.Price;
double startPrice = ExtensionAnchor.Price;
Point anchorExtensionPoint = ExtensionAnchor.GetPoint(chartControl, panel, chartScale);
Point anchorStartPoint = StartAnchor.GetPoint(chartControl, panel, chartScale);
Point anchorEndPoint = EndAnchor.GetPoint(chartControl, panel, chartScale);
Point midPointExtension = new Point((anchorExtensionPoint.X + anchorEndPoint.X) / 2, (anchorExtensionPoint.Y + anchorEndPoint.Y) / 2);
foreach (PriceLevel pl in PriceLevels.Where(pl => pl.IsVisible))
{
double levelPrice = (startPrice + ((pl.Value / 100) * totalPriceRange));
float pixelY = chartScale.GetYByValue(levelPrice);
float pixelX = anchorExtensionPoint.X > anchorEndPoint.X ?
(float)(anchorExtensionPoint.X - (Math.Abs((anchorEndPoint.X - anchorExtensionPoint.X) * (pl.Value / 100)))) :
(float)(anchorExtensionPoint.X + ((anchorEndPoint.X - anchorExtensionPoint.X) * (pl.Value / 100)));
Point startPoint = new Point(pixelX, pixelY);
Point endPoint = new Point(startPoint.X + (midPointExtension.X - anchorStartPoint.X), startPoint.Y + (midPointExtension.Y - anchorStartPoint.Y));
Point maxLevelPoint = GetExtendedPoint(startPoint, endPoint);
yield return(new Tuple <Point, Point>(new Point(Math.Max(maxLevelPoint.X, 1), Math.Max(maxLevelPoint.Y, 1)), startPoint));
}
}
public override void OnRender(ChartControl chartControl, ChartScale chartScale)
{
if (Anchors.All(a => a.IsEditing))
{
return;
}
RenderTarget.AntialiasMode = SharpDX.Direct2D1.AntialiasMode.PerPrimitive;
ChartPanel chartPanel = chartControl.ChartPanels[PanelIndex];
Point anchorStartPoint = StartAnchor.GetPoint(chartControl, chartPanel, chartScale);
Point anchorEndPoint = EndAnchor.GetPoint(chartControl, chartPanel, chartScale);
Point anchorExtensionPoint = ExtensionAnchor.GetPoint(chartControl, chartPanel, chartScale);
Point midPointExtension = new Point((anchorExtensionPoint.X + anchorEndPoint.X) / 2, (anchorExtensionPoint.Y + anchorEndPoint.Y) / 2);
if (CalculationMethod == AndrewsPitchforkCalculationMethod.Schiff)
{
anchorStartPoint = new Point(anchorStartPoint.X, (anchorStartPoint.Y + anchorEndPoint.Y) / 2);
}
else if (CalculationMethod == AndrewsPitchforkCalculationMethod.ModifiedSchiff)
{
anchorStartPoint = new Point((anchorEndPoint.X + anchorStartPoint.X) / 2, (anchorEndPoint.Y + anchorStartPoint.Y) / 2);
}
AnchorLineStroke.RenderTarget = RenderTarget;
RetracementLineStroke.RenderTarget = RenderTarget;
// Align to full pixel to avoid unneeded aliasing
double strokePixAdj = AnchorLineStroke.Width % 2 == 0 ? 0.5d : 0d;
Vector pixelAdjustVec = new Vector(strokePixAdj, strokePixAdj);
SharpDX.Vector2 startVec = (anchorStartPoint + pixelAdjustVec).ToVector2();
SharpDX.Vector2 endVec = (anchorEndPoint + pixelAdjustVec).ToVector2();
SharpDX.Direct2D1.Brush tmpBrush = IsInHitTest ? chartControl.SelectionBrush : AnchorLineStroke.BrushDX;
SharpDX.Vector2 startOriginVec = (StartAnchor.GetPoint(chartControl, chartPanel, chartScale) + pixelAdjustVec).ToVector2();
RenderTarget.DrawLine(startOriginVec, endVec, tmpBrush, AnchorLineStroke.Width, AnchorLineStroke.StrokeStyle);
// Is second anchor set yet? Check both so we correctly re-draw during extension anchor editing
if (ExtensionAnchor.IsEditing && EndAnchor.IsEditing)
{
return;
}
SharpDX.Vector2 extVector = anchorExtensionPoint.ToVector2();
tmpBrush = IsInHitTest ? chartControl.SelectionBrush : RetracementLineStroke.BrushDX;
RenderTarget.DrawLine(endVec, extVector, tmpBrush, RetracementLineStroke.Width, RetracementLineStroke.StrokeStyle);
// If we're doing a hit test pass, don't draw price levels at all, we dont want those to count for
// hit testing
if (IsInHitTest || PriceLevels == null || !PriceLevels.Any())
{
return;
}
SetAllPriceLevelsRenderTarget();
// Calculate total y range for % calculation on each level
double totalPriceRange = EndAnchor.Price - ExtensionAnchor.Price;
double startPrice = ExtensionAnchor.Price;
float minLevelY = float.MaxValue;
float maxLevelY = float.MinValue;
// Store values to use in correct render order
Point lastEndPoint = new Point(0, 0);
Point lastStartPoint = new Point(0, 0);
Stroke lastStroke = null;
List <Tuple <PriceLevel, Point> > textPoints = new List <Tuple <PriceLevel, Point> >();
foreach (PriceLevel priceLevel in PriceLevels.Where(pl => pl.IsVisible && pl.Stroke != null).OrderBy(pl => pl.Value))
{
double levelPrice = (startPrice + ((priceLevel.Value / 100) * totalPriceRange));
float pixelY = chartScale.GetYByValue(levelPrice);
float pixelX = anchorExtensionPoint.X > anchorEndPoint.X ?
priceLevel.Value >= 0 ? (float)(anchorExtensionPoint.X - (Math.Abs((anchorEndPoint.X - anchorExtensionPoint.X) * (priceLevel.Value / 100)))) : (float)(anchorExtensionPoint.X + ((anchorEndPoint.X - anchorExtensionPoint.X) * (priceLevel.Value / 100))):
priceLevel.Value >= 0 ? (float)(anchorExtensionPoint.X + ((anchorEndPoint.X - anchorExtensionPoint.X) * (priceLevel.Value / 100))) : (float)(anchorExtensionPoint.X - (Math.Abs((anchorEndPoint.X - anchorExtensionPoint.X) * (priceLevel.Value / 100))));
Point startPoint = new Point(pixelX, pixelY);
Point endPoint = new Point(startPoint.X + (midPointExtension.X - anchorStartPoint.X), startPoint.Y + (midPointExtension.Y - anchorStartPoint.Y));
Point maxLevelPoint = GetExtendedPoint(startPoint, endPoint);
if (priceLevel.Value == 50)
{
RenderTarget.DrawLine(startVec, maxLevelPoint.ToVector2(), priceLevel.Stroke.BrushDX, priceLevel.Stroke.Width, priceLevel.Stroke.StrokeStyle);
}
else
{
RenderTarget.DrawLine(startPoint.ToVector2(), maxLevelPoint.ToVector2(), priceLevel.Stroke.BrushDX, priceLevel.Stroke.Width, priceLevel.Stroke.StrokeStyle);
}
if (lastStroke == null)
{
lastStroke = new Stroke();
}
else
{
SharpDX.Direct2D1.PathGeometry lineGeometry = new SharpDX.Direct2D1.PathGeometry(Core.Globals.D2DFactory);
SharpDX.Direct2D1.GeometrySink sink = lineGeometry.Open();
sink.BeginFigure(lastEndPoint.ToVector2(), SharpDX.Direct2D1.FigureBegin.Filled);
// Does the fill color need to fill a corner? Check and add a point
if (lastEndPoint.Y != maxLevelPoint.Y && lastEndPoint.X != maxLevelPoint.X)
{
double boundaryX;
double boundaryY;
if (lastEndPoint.Y <= ChartPanel.Y || lastEndPoint.Y >= ChartPanel.Y + ChartPanel.H)
{
boundaryY = lastEndPoint.Y;
boundaryX = maxLevelPoint.X;
}
else
{
boundaryY = maxLevelPoint.Y;
boundaryX = lastEndPoint.X;
}
sink.AddLine(new SharpDX.Vector2((float)boundaryX, (float)boundaryY));
}
sink.AddLine(maxLevelPoint.ToVector2());
sink.AddLine(startPoint.ToVector2());
sink.AddLine(lastStartPoint.ToVector2());
sink.EndFigure(SharpDX.Direct2D1.FigureEnd.Closed);
sink.Close();
RenderTarget.FillGeometry(lineGeometry, lastStroke.BrushDX);
lineGeometry.Dispose();
}
if (IsTextDisplayed)
{
textPoints.Add(new Tuple <PriceLevel, Point>(priceLevel, maxLevelPoint));
}
priceLevel.Stroke.CopyTo(lastStroke);
lastStroke.Opacity = PriceLevelOpacity;
lastStartPoint = startPoint;
lastEndPoint = maxLevelPoint;
minLevelY = Math.Min(pixelY, minLevelY);
maxLevelY = Math.Max(pixelY, maxLevelY);
}
// Render text last so it's on top of the price level colors
if (IsTextDisplayed)
{
foreach (Tuple <PriceLevel, Point> textPoint in textPoints)
{
DrawPriceLevelText(0, 0, textPoint.Item2, textPoint.Item1, chartPanel);
}
}
}
public override bool IsAlertConditionTrue(AlertConditionItem conditionItem, Condition condition, ChartAlertValue[] values,
ChartControl chartControl, ChartScale chartScale)
{
PriceLevel priceLevel = conditionItem.Tag as PriceLevel;
if (priceLevel == null)
{
return(false);
}
ChartPanel chartPanel = chartControl.ChartPanels[PanelIndex];
Point anchorStartPoint = StartAnchor.GetPoint(chartControl, chartPanel, chartScale);
Point anchorEndPoint = EndAnchor.GetPoint(chartControl, chartPanel, chartScale);
Point anchorExtensionPoint = ExtensionAnchor.GetPoint(chartControl, chartPanel, chartScale);
Point midPointExtension = new Point((anchorExtensionPoint.X + anchorEndPoint.X) / 2, (anchorExtensionPoint.Y + anchorEndPoint.Y) / 2);
if (CalculationMethod == AndrewsPitchforkCalculationMethod.Schiff)
{
anchorStartPoint = new Point(anchorStartPoint.X, (anchorStartPoint.Y + anchorEndPoint.Y) / 2);
}
else if (CalculationMethod == AndrewsPitchforkCalculationMethod.ModifiedSchiff)
{
anchorStartPoint = new Point((anchorEndPoint.X + anchorStartPoint.X) / 2, (anchorEndPoint.Y + anchorStartPoint.Y) / 2);
}
double totalPriceRange = EndAnchor.Price - ExtensionAnchor.Price;
double startPrice = ExtensionAnchor.Price;
double levelPrice = (startPrice + ((priceLevel.Value / 100) * totalPriceRange));
float pixelY = chartScale.GetYByValue(levelPrice);
float pixelX = anchorExtensionPoint.X > anchorEndPoint.X ?
(float)(anchorExtensionPoint.X - (Math.Abs((anchorEndPoint.X - anchorExtensionPoint.X) * (priceLevel.Value / 100)))) :
(float)(anchorExtensionPoint.X + ((anchorEndPoint.X - anchorExtensionPoint.X) * (priceLevel.Value / 100)));
Point alertStartPoint = new Point(pixelX, pixelY);
Point endPoint = new Point(alertStartPoint.X + (midPointExtension.X - anchorStartPoint.X), alertStartPoint.Y + (midPointExtension.Y - anchorStartPoint.Y));
Point alertEndPoint = GetExtendedPoint(alertStartPoint, endPoint);
double firstBarX = values[0].ValueType == ChartAlertValueType.StaticValue ? pixelX : chartControl.GetXByTime(values[0].Time);
double firstBarY = chartScale.GetYByValue(values[0].Value);
Point barPoint = new Point(firstBarX, firstBarY);
// Check bars are not yet to our drawing tool
if (firstBarX < alertStartPoint.X || firstBarX > alertEndPoint.X)
{
return(false);
}
// NOTE: 'left / right' is relative to if line was vertical. It can end up backwards too
MathHelper.PointLineLocation pointLocation = MathHelper.GetPointLineLocation(alertStartPoint, alertEndPoint, barPoint);
// For vertical things, think of a vertical line rotated 90 degrees to lay flat, where it's normal vector is 'up'
switch (condition)
{
case Condition.Greater: return(pointLocation == MathHelper.PointLineLocation.LeftOrAbove);
case Condition.GreaterEqual: return(pointLocation == MathHelper.PointLineLocation.LeftOrAbove || pointLocation == MathHelper.PointLineLocation.DirectlyOnLine);
case Condition.Less: return(pointLocation == MathHelper.PointLineLocation.RightOrBelow);
case Condition.LessEqual: return(pointLocation == MathHelper.PointLineLocation.RightOrBelow || pointLocation == MathHelper.PointLineLocation.DirectlyOnLine);
case Condition.Equals: return(pointLocation == MathHelper.PointLineLocation.DirectlyOnLine);
case Condition.NotEqual: return(pointLocation != MathHelper.PointLineLocation.DirectlyOnLine);
case Condition.CrossAbove:
case Condition.CrossBelow:
Predicate <ChartAlertValue> predicate = v =>
{
double barX = chartControl.GetXByTime(v.Time);
double barY = chartScale.GetYByValue(v.Value);
Point stepBarPoint = new Point(barX, barY);
// NOTE: 'left / right' is relative to if line was vertical. It can end up backwards too
MathHelper.PointLineLocation ptLocation = MathHelper.GetPointLineLocation(alertStartPoint, alertEndPoint, stepBarPoint);
if (condition == Condition.CrossAbove)
{
return(ptLocation == MathHelper.PointLineLocation.LeftOrAbove);
}
return(ptLocation == MathHelper.PointLineLocation.RightOrBelow);
};
return(MathHelper.DidPredicateCross(values, predicate));
}
return(false);
}
