public override void OnMouseMove(ChartControl chartControl, ChartPanel chartPanel, ChartScale chartScale, ChartAnchor dataPoint)
{
if (IsLocked && DrawingState != DrawingState.Building)
{
return;
}
switch (DrawingState)
{
case DrawingState.Building:
if (StartAnchor.IsEditing)
{
dataPoint.CopyDataValues(StartAnchor);
}
if (EndAnchor.IsEditing)
{
dataPoint.CopyDataValues(EndAnchor);
}
break;
case DrawingState.Editing:
dataPoint.CopyDataValues(EndAnchor);
break;
case DrawingState.Moving:
StartAnchor.MoveAnchor(InitialMouseDownAnchor, dataPoint, chartControl, chartPanel, chartScale, this);
EndAnchor.MoveAnchor(InitialMouseDownAnchor, dataPoint, chartControl, chartPanel, chartScale, this);
break;
}
}
public override void OnMouseDown(ChartControl chartControl, ChartPanel chartPanel, ChartScale chartScale, ChartAnchor dataPoint)
{
switch (DrawingState)
{
case DrawingState.Building:
if (StartAnchor.IsEditing)
{
dataPoint.CopyDataValues(StartAnchor);
dataPoint.CopyDataValues(EndAnchor);
StartAnchor.IsEditing = false;
}
else if (EndAnchor.IsEditing)
{
dataPoint.CopyDataValues(EndAnchor);
EndAnchor.IsEditing = false;
DrawingState = DrawingState.Normal;
IsSelected = false;
}
break;
case DrawingState.Normal:
Point p = dataPoint.GetPoint(chartControl, chartPanel, chartScale);
Cursor c = GetCursor(chartControl, chartPanel, chartScale, p);
if (c == Cursors.SizeWE)
{
int editingAnchor = GetClosestBarAnchor(chartControl, p, false);
int i = anchorBars.IndexOf(editingAnchor);
if (editingAnchor != int.MinValue && i > -1)
{
StartAnchor.UpdateXFromPoint(new Point(anchorBars[i == 0 ? i : i - 1], chartPanel.Y + chartPanel.H), chartControl, chartScale);
EndAnchor.UpdateXFromPoint(new Point(anchorBars[i == 0 ? i + 1 : i], chartPanel.Y + chartPanel.H), chartControl, chartScale);
EndAnchor.IsEditing = true;
DrawingState = DrawingState.Editing;
}
}
else if (c == Cursors.SizeAll)
{
int editingAnchor = GetClosestBarAnchor(chartControl, p, true);
int i = anchorBars.IndexOf(editingAnchor);
if (editingAnchor != int.MinValue && i > -1)
{
StartAnchor.UpdateXFromPoint(new Point(anchorBars[i - 1], chartPanel.Y + chartPanel.H), chartControl, chartScale);
EndAnchor.UpdateXFromPoint(new Point(anchorBars[i], chartPanel.Y + chartPanel.H), chartControl, chartScale);
// We have to update the InitialMouseDownAnchor here because we moved our Start/End anchors
InitialMouseDownAnchor = dataPoint.Clone() as ChartAnchor;
DrawingState = DrawingState.Moving;
}
}
else
{
IsSelected = false;
}
break;
}
}
public override void OnMouseMove(ChartControl chartControl, ChartPanel chartPanel, ChartScale chartScale, ChartAnchor dataPoint)
{
if (IsLocked && DrawingState != DrawingState.Building)
{
return;
}
if (DrawingState == DrawingState.Building)
{
// Start anchor will not be editing here because we start building as soon as user clicks, which
// plops down a start anchor right away
if (EndAnchor.IsEditing)
{
dataPoint.CopyDataValues(EndAnchor);
}
else if (ExtensionAnchor.IsEditing)
{
dataPoint.CopyDataValues(ExtensionAnchor);
}
}
else if (DrawingState == DrawingState.Editing && editingAnchor != null)
{
dataPoint.CopyDataValues(editingAnchor);
}
else if (DrawingState == DrawingState.Moving)
{
foreach (ChartAnchor anchor in Anchors)
{
anchor.MoveAnchor(InitialMouseDownAnchor, dataPoint, chartControl, chartPanel, chartScale, this);
}
// Don't forget to update delta to last used
}
}
public override void OnMouseMove(ChartControl chartControl, ChartPanel chartPanel, ChartScale chartScale, ChartAnchor dataPoint)
{
if (IsLocked && DrawingState != DrawingState.Building)
{
return;
}
switch (DrawingState)
{
case DrawingState.Building:
foreach (ChartAnchor ca in ChartAnchors)
{
if (ca.IsEditing)
{
dataPoint.CopyDataValues(ca);
}
}
break;
case DrawingState.Editing:
if (editingAnchor != null)
{
dataPoint.CopyDataValues(editingAnchor);
}
break;
case DrawingState.Moving:
foreach (ChartAnchor ca in ChartAnchors)
{
ca.MoveAnchor(InitialMouseDownAnchor, dataPoint, chartControl, chartPanel, chartScale, this);
}
break;
}
}
public override void OnMouseMove(ChartControl chartControl, ChartPanel chartPanel, ChartScale chartScale, ChartAnchor dataPoint)
{
if (IsLocked && DrawingState != DrawingState.Building)
{
return;
}
if (DrawingState == DrawingState.Building)
{
// start anchor will not be editing here because we start building as soon as user clicks, which
// plops down a start anchor right away
if (EndAnchor.IsEditing)
{
dataPoint.CopyDataValues(EndAnchor);
}
}
else if (DrawingState == DrawingState.Editing && editingAnchor != null)
{
// if its a line with two anchors, update both x/y at once
dataPoint.CopyDataValues(editingAnchor);
}
else if (DrawingState == DrawingState.Moving)
{
foreach (ChartAnchor anchor in Anchors)
{
anchor.MoveAnchor(InitialMouseDownAnchor, dataPoint, chartControl, chartPanel, chartScale, this);
}
}
//lastMouseMovePoint.Value, point, chartControl, chartScale);
}
public override void OnMouseMove(ChartControl chartControl, ChartPanel chartPanel, ChartScale chartScale, ChartAnchor dataPoint)
{
if (IsLocked && DrawingState != DrawingState.Building)
{
return;
}
if (DrawingState == DrawingState.Building && EndAnchor.IsEditing)
{
if (Mode == RegionHighlightMode.Price)
{
dataPoint.Time = chartControl.FirstTimePainted.AddSeconds((chartControl.LastTimePainted - chartControl.FirstTimePainted).TotalSeconds / 2);
}
else
{
dataPoint.Price = chartScale.MinValue + (chartScale.MaxMinusMin / 2);
}
dataPoint.CopyDataValues(EndAnchor);
//Point buildAdjusted = Mode == RegionHighlightMode.Time ? new Point(point.X, startAnchorPoint.Y) : new Point(startAnchorPoint.X, point.Y);
//EndAnchor.UpdateFromPoint(buildAdjusted, chartControl, chartScale);
}
else if (DrawingState == DrawingState.Editing)
{
dataPoint.CopyDataValues(editingAnchor);
}
else if (DrawingState == DrawingState.Moving)
{
foreach (ChartAnchor anchor in Anchors)
{
anchor.MoveAnchor(InitialMouseDownAnchor, dataPoint, chartControl, chartPanel, chartScale, this);
}
}
}
public override void OnMouseDown(ChartControl chartControl, ChartPanel chartPanel, ChartScale chartScale, ChartAnchor dataPoint)
{
switch (DrawingState)
{
case DrawingState.Building:
if (EntryAnchor.IsEditing)
{
dataPoint.CopyDataValues(EntryAnchor);
dataPoint.CopyDataValues(RiskAnchor);
EntryAnchor.IsEditing = false;
entryPrice = AttachedTo.Instrument.MasterInstrument.RoundToTickSize(EntryAnchor.Price);
}
else if (RiskAnchor.IsEditing)
{
dataPoint.CopyDataValues(RiskAnchor);
RiskAnchor.IsEditing = false;
stopPrice = AttachedTo.Instrument.MasterInstrument.RoundToTickSize(RiskAnchor.Price);
SetReward();
// we set the anchor for the target after stop mouse down event via SetReward()
//however we need make sure Time is in view when builiding, but always when SetRreward is used..
RewardAnchor.Time = EntryAnchor.Time;
RewardAnchor.SlotIndex = EntryAnchor.SlotIndex;
RewardAnchor.IsEditing = false;
}
// if the anchors are no longer being edited, set the drawing state to normal and unselect the object
if (!EntryAnchor.IsEditing && !RiskAnchor.IsEditing && !RewardAnchor.IsEditing)
{
DrawingState = DrawingState.Normal;
IsSelected = false;
}
break;
case DrawingState.Normal:
Point point = dataPoint.GetPoint(chartControl, chartPanel, chartScale);
//find which anchor has been clicked relative to the mouse point and make whichever anchor now editable
editingAnchor = GetClosestAnchor(chartControl, chartPanel, chartScale, cursorSensitivity, point);
if (editingAnchor != null)
{
editingAnchor.IsEditing = true;
DrawingState = DrawingState.Editing;
}
else if (GetCursor(chartControl, chartPanel, chartScale, point) == null)
{
IsSelected = false; // missed
}
else
{
// didnt click an anchor but on a line so start moving
DrawingState = DrawingState.Moving;
}
break;
}
}
public override void OnMouseDown(ChartControl chartControl, ChartPanel chartPanel, ChartScale chartScale, ChartAnchor dataPoint)
{
switch (DrawingState)
{
case DrawingState.Building:
if (StartAnchor.IsEditing)
{
dataPoint.CopyDataValues(StartAnchor);
StartAnchor.IsEditing = false;
// give end anchor something to start with so we dont try to render it with bad values right away
dataPoint.CopyDataValues(EndAnchor);
}
else if (EndAnchor.IsEditing)
{
dataPoint.CopyDataValues(EndAnchor);
EndAnchor.IsEditing = false;
}
// is initial building done (both anchors set)
if (!StartAnchor.IsEditing && !EndAnchor.IsEditing)
{
DrawingState = DrawingState.Normal;
IsSelected = false;
}
break;
case DrawingState.Normal:
Point point = dataPoint.GetPoint(chartControl, chartPanel, chartScale);
// see if they clicked near a point to edit, if so start editing
editingAnchor = GetClosestAnchor(chartControl, chartPanel, chartScale, cursorSensitivity, point);
if (editingAnchor != null)
{
editingAnchor.IsEditing = true;
DrawingState = DrawingState.Editing;
}
else
{
if (GetCursor(chartControl, chartPanel, chartScale, point) != null)
{
DrawingState = DrawingState.Moving;
}
else
{
// user whiffed.
IsSelected = false;
}
}
break;
}
}
public override void OnMouseMove(ChartControl chartControl, ChartPanel chartPanel, ChartScale chartScale, ChartAnchor dataPoint)
{
if (IsLocked && DrawingState != DrawingState.Building || !IsVisible)
{
return;
}
if (DrawingState == DrawingState.Building)
{
if (EntryAnchor.IsEditing)
{
dataPoint.CopyDataValues(EntryAnchor);
}
else if (RiskAnchor.IsEditing)
{
dataPoint.CopyDataValues(RiskAnchor);
}
else if (RewardAnchor.IsEditing)
{
dataPoint.CopyDataValues(RewardAnchor);
}
}
else if (DrawingState == DrawingState.Editing && editingAnchor != null)
{
dataPoint.CopyDataValues(editingAnchor);
if (editingAnchor != EntryAnchor)
{
if (editingAnchor != RewardAnchor && Ratio.ApproxCompare(0) != 0)
{
SetReward();
}
else if (Ratio.ApproxCompare(0) != 0)
{
SetRisk();
}
}
}
else if (DrawingState == DrawingState.Moving)
{
foreach (ChartAnchor anchor in Anchors)
{
anchor.MoveAnchor(InitialMouseDownAnchor, dataPoint, chartControl, chartPanel, chartScale, this);
}
}
entryPrice = AttachedTo.Instrument.MasterInstrument.RoundToTickSize(EntryAnchor.Price);
stopPrice = AttachedTo.Instrument.MasterInstrument.RoundToTickSize(RiskAnchor.Price);
targetPrice = AttachedTo.Instrument.MasterInstrument.RoundToTickSize(RewardAnchor.Price);
}
public override void OnMouseDown(ChartControl chartControl, ChartPanel chartPanel, ChartScale chartScale, ChartAnchor dataPoint)
{
switch (DrawingState)
{
case DrawingState.Building:
if (PointsPerBar < 0)
{
PointsPerBar = AttachedTo.Instrument.MasterInstrument.TickSize;
}
dataPoint.CopyDataValues(Anchor);
Anchor.IsEditing = false;
DrawingState = DrawingState.Normal;
IsSelected = false;
break;
case DrawingState.Normal:
// make sure they clicked near our anchor or a gann line
Point point = dataPoint.GetPoint(chartControl, chartPanel, chartScale);
if (GetClosestAnchor(chartControl, chartPanel, chartScale, 10, point) == Anchor)
{
DrawingState = DrawingState.Editing;
}
else if (GetCursor(chartControl, chartControl.ChartPanels[PanelIndex], chartScale, point) == Cursors.SizeAll)
{
DrawingState = DrawingState.Moving;
}
else
{
IsSelected = false;
}
break;
}
}
public override void OnMouseMove(ChartControl chartControl, ChartPanel chartPanel, ChartScale chartScale, ChartAnchor dataPoint)
{
if (IsLocked && DrawingState != DrawingState.Building)
{
return;
}
if (DrawingState == DrawingState.Building)
{
// start anchor will not be editing here because we start building as soon as user clicks, which
// plops down a start anchor right away. check these seperately because they will both initially
// be in edit mode.
if (EndAnchor.IsEditing)
{
dataPoint.CopyDataValues(EndAnchor);
dataPoint.CopyDataValues(TextAnchor);
isTextCreated = false;
}
else if (TextAnchor.IsEditing)
{
dataPoint.CopyDataValues(TextAnchor);
}
}
else if (DrawingState == DrawingState.Editing && editingAnchor != null)
{
dataPoint.CopyDataValues(editingAnchor);
if (editingAnchor == StartAnchor || editingAnchor == EndAnchor)
{
isTextCreated = false;
}
}
else if (DrawingState == DrawingState.Moving)
{
foreach (ChartAnchor anchor in Anchors)
{
anchor.MoveAnchor(InitialMouseDownAnchor, dataPoint, chartControl, chartPanel, chartScale, this);
}
// dont forget to update delta to last used
if (textLayout != null)
{
textLayout.Dispose();
}
textLayout = null;
}
}
public override void OnMouseMove(ChartControl chartControl, ChartPanel chartPanel, ChartScale chartScale, ChartAnchor dataPoint)
{
if (IsLocked && DrawingState != DrawingState.Building)
{
return;
}
if (DrawingState == DrawingState.Building)
{
// start anchor will not be editing here because we start building as soon as user clicks, which
// plops down a start anchor right away
if (EndAnchor.IsEditing)
{
dataPoint.CopyDataValues(EndAnchor);
StartAnchor.Price = EndAnchor.Price;
}
}
else if (DrawingState == DrawingState.Editing && editingAnchor != null)
{
editingAnchor.Price = dataPoint.Price;
StartAnchor.Price = dataPoint.Price;
EndAnchor.Price = dataPoint.Price;
if (editingAnchor.Time == StartAnchor.Time)
{
StartAnchor.Time = dataPoint.Time;
}
else
{
EndAnchor.Time = dataPoint.Time;
}
}
else if (DrawingState == DrawingState.Moving)
{
foreach (ChartAnchor anchor in Anchors)
{
anchor.MoveAnchor(lastMouseMoveDataPoint, dataPoint, chartControl, chartPanel, chartScale, this); //lastMouseMovePoint.Value, point, chartControl, chartScale);
}
dataPoint.CopyDataValues(lastMouseMoveDataPoint);
}
}
private static Arc ArcCore(NinjaScriptBase owner, bool isAutoScale, string tag,
int startBarsAgo, DateTime startTime, double startY, int endBarsAgo, DateTime endTime, double endY,
Brush brush, DashStyleHelper dashStyle, int width, bool isGlobal, string templateName)
{
if (owner == null)
{
throw new ArgumentException("owner");
}
if (startTime == Core.Globals.MinDate && endTime == Core.Globals.MinDate && startBarsAgo == int.MinValue && endBarsAgo == int.MinValue)
{
throw new ArgumentException("bad start/end date/time");
}
if (string.IsNullOrWhiteSpace(tag))
{
throw new ArgumentException("tag cant be null or empty", "tag");
}
if (isGlobal && tag[0] != GlobalDrawingToolManager.GlobalDrawingToolTagPrefix)
{
tag = GlobalDrawingToolManager.GlobalDrawingToolTagPrefix + tag;
}
Arc newArc = DrawingTool.GetByTagOrNew(owner, typeof(Arc), tag, templateName) as Arc;
if (newArc == null)
{
return(null);
}
DrawingTool.SetDrawingToolCommonValues(newArc, tag, isAutoScale, owner, isGlobal);
// dont nuke existing anchor refs on the instance
ChartAnchor startAnchor = DrawingTool.CreateChartAnchor(owner, startBarsAgo, startTime, startY);
ChartAnchor endAnchor = DrawingTool.CreateChartAnchor(owner, endBarsAgo, endTime, endY);
startAnchor.CopyDataValues(newArc.StartAnchor);
endAnchor.CopyDataValues(newArc.EndAnchor);
if (brush != null)
{
newArc.Stroke = new Stroke(brush, dashStyle, width, 50)
{
RenderTarget = newArc.Stroke.RenderTarget
};
newArc.ArcStroke = new Stroke(brush, dashStyle, width)
{
RenderTarget = newArc.ArcStroke.RenderTarget
};
}
newArc.SetState(State.Active);
return(newArc);
}
private static AndrewsPitchfork AndrewsPitchforkCore(NinjaScriptBase owner,
string tag, bool isAutoScale,
int anchor1BarsAgo, DateTime anchor1Time, double anchor1Y,
int anchor2BarsAgo, DateTime anchor2Time, double anchor2Y,
int anchor3BarsAgo, DateTime anchor3Time, double anchor3Y,
Brush brush, DashStyleHelper dashStyle, int width,
bool isGlobal, string templateName)
{
if (owner == null)
{
throw new ArgumentException("owner");
}
if (string.IsNullOrWhiteSpace(tag))
{
throw new ArgumentException(@"tag cant be null or empty", "tag");
}
if (isGlobal && tag[0] != GlobalDrawingToolManager.GlobalDrawingToolTagPrefix)
{
tag = GlobalDrawingToolManager.GlobalDrawingToolTagPrefix + tag;
}
AndrewsPitchfork pitchfork = DrawingTool.GetByTagOrNew(owner, typeof(AndrewsPitchfork), tag, templateName) as AndrewsPitchfork;
if (pitchfork == null)
{
return(null);
}
DrawingTool.SetDrawingToolCommonValues(pitchfork, tag, isAutoScale, owner, isGlobal);
ChartAnchor startAnchor = DrawingTool.CreateChartAnchor(owner, anchor1BarsAgo, anchor1Time, anchor1Y);
ChartAnchor endAnchor = DrawingTool.CreateChartAnchor(owner, anchor2BarsAgo, anchor2Time, anchor2Y);
ChartAnchor extAnchor = DrawingTool.CreateChartAnchor(owner, anchor3BarsAgo, anchor3Time, anchor3Y);
startAnchor.CopyDataValues(pitchfork.StartAnchor);
endAnchor.CopyDataValues(pitchfork.EndAnchor);
extAnchor.CopyDataValues(pitchfork.ExtensionAnchor);
if (string.IsNullOrEmpty(templateName) || brush != null)
{
pitchfork.AnchorLineStroke.Width = width;
pitchfork.RetracementLineStroke = new Stroke(brush, dashStyle, width)
{
RenderTarget = pitchfork.RetracementLineStroke.RenderTarget
};
}
pitchfork.SetState(State.Active);
return(pitchfork);
}
private static T DrawRangeProfileTypeCore <T>(NinjaScriptBase owner, bool isAutoScale, string tag,
int startBarsAgo, DateTime startTime, double startY, int endBarsAgo, DateTime endTime, double endY,
Brush brush, DashStyleHelper dashStyle, int width, bool isGlobal, string templateName, Model model) where T : RangeProfile
{
if (owner == null)
{
throw new ArgumentException("owner");
}
if (string.IsNullOrWhiteSpace(tag))
{
throw new ArgumentException(@"tag cant be null or empty", "tag");
}
if (isGlobal && tag[0] != GlobalDrawingToolManager.GlobalDrawingToolTagPrefix)
{
tag = string.Format("{0}{1}", GlobalDrawingToolManager.GlobalDrawingToolTagPrefix, tag);
}
T lineT = DrawingTool.GetByTagOrNew(owner, typeof(T), tag, templateName) as T;
lineT.model = model;
if (lineT == null)
{
return(null);
}
if (startTime == Core.Globals.MinDate && endTime == Core.Globals.MinDate && startBarsAgo == int.MinValue && endBarsAgo == int.MinValue)
{
throw new ArgumentException("bad start/end date/time");
}
DrawingTool.SetDrawingToolCommonValues(lineT, tag, isAutoScale, owner, isGlobal);
// dont nuke existing anchor refs on the instance
ChartAnchor startAnchor;
startAnchor = DrawingTool.CreateChartAnchor(owner, startBarsAgo, startTime, startY);
ChartAnchor endAnchor = DrawingTool.CreateChartAnchor(owner, endBarsAgo, endTime, endY);
startAnchor.CopyDataValues(lineT.StartAnchor);
endAnchor.CopyDataValues(lineT.EndAnchor);
/*if (brush != null)
* lineT.LineStroke = new Stroke(brush, dashStyle, width);*/
lineT.SetState(State.Active);
return(lineT);
}
public override void OnMouseMove(ChartControl chartControl, ChartPanel chartPanel, ChartScale chartScale, ChartAnchor dataPoint)
{
if (IsLocked && DrawingState != DrawingState.Building)
{
return;
}
if (DrawingState == DrawingState.Editing)
{
dataPoint.CopyDataValues(Anchor);
}
else if (DrawingState == DrawingState.Moving)
{
Anchor.MoveAnchor(InitialMouseDownAnchor, dataPoint, chartControl, chartPanel, chartScale, this);
}
}
private static Ruler RulerCore(NinjaScriptBase owner, string tag, bool isAutoScale, int startBarsAgo, DateTime startTime, double startY,
int endBarsAgo, DateTime endTime, double endY, int textBarsAgo, DateTime textTime, double textY, bool isGlobal, string templateName)
{
if (owner == null)
{
throw new ArgumentException("owner");
}
if (startTime == Core.Globals.MinDate && endTime == Core.Globals.MinDate && startBarsAgo == int.MinValue && endBarsAgo == int.MinValue)
{
throw new ArgumentException("bad start/end date/time");
}
if (string.IsNullOrWhiteSpace(tag))
{
throw new ArgumentException(@"tag cant be null or empty", "tag");
}
if (isGlobal && tag[0] != GlobalDrawingToolManager.GlobalDrawingToolTagPrefix)
{
tag = GlobalDrawingToolManager.GlobalDrawingToolTagPrefix + tag;
}
Ruler ruler = DrawingTool.GetByTagOrNew(owner, typeof(Ruler), tag, templateName) as Ruler;
if (ruler == null)
{
return(null);
}
DrawingTool.SetDrawingToolCommonValues(ruler, tag, isAutoScale, owner, isGlobal);
ChartAnchor startAnchor = DrawingTool.CreateChartAnchor(owner, startBarsAgo, startTime, startY);
ChartAnchor endAnchor = DrawingTool.CreateChartAnchor(owner, endBarsAgo, endTime, endY);
ChartAnchor txtAnchor = DrawingTool.CreateChartAnchor(owner, textBarsAgo, textTime, textY);
startAnchor.CopyDataValues(ruler.StartAnchor);
endAnchor.CopyDataValues(ruler.EndAnchor);
txtAnchor.CopyDataValues(ruler.TextAnchor);
ruler.SetState(State.Active);
return(ruler);
}
private static Region Region(NinjaScriptBase owner, string tag,
int startBarsAgo, DateTime startTime, int endBarsAgo, DateTime endTime,
ISeries <double> series1, ISeries <double> series2, double price,
Brush outlineBrush, Brush areaBrush, int areaOpacity, int displacement)
{
Region region = DrawingTool.GetByTagOrNew(owner, typeof(Region), tag, null) as Region;
if (region == null)
{
return(null);
}
DrawingTool.SetDrawingToolCommonValues(region, tag, false, owner, false);
ChartAnchor startAnchor = DrawingTool.CreateChartAnchor(owner, startBarsAgo, startTime, 0);
ChartAnchor endAnchor = DrawingTool.CreateChartAnchor(owner, endBarsAgo, endTime, 0);
startAnchor.CopyDataValues(region.StartAnchor);
endAnchor.CopyDataValues(region.EndAnchor);
if (series1 == null && series2 == null)
{
throw new ArgumentException("At least one series is required");
}
region.Series1 = series1;
region.Series2 = series2;
region.Price = price;
region.Displacement = displacement;
region.AreaBrush = areaBrush;
region.AreaOpacity = areaOpacity;
region.OutlineStroke = outlineBrush != null ? new Stroke(outlineBrush) : null;
region.SetState(State.Active);
region.DrawingState = DrawingState.Normal;
region.IsSelected = false;
return(region);
}
private static GannFan GannFanCore(NinjaScriptBase owner, bool isAutoScale, string tag, int barsAgo, DateTime time, double y, bool isGlobal, string templateName)
{
if (owner == null)
{
throw new ArgumentException("owner");
}
if (time == Core.Globals.MinDate && barsAgo == int.MinValue)
{
throw new ArgumentException("bad start/end date/time");
}
if (string.IsNullOrWhiteSpace(tag))
{
throw new ArgumentException("tag cant be null or empty");
}
if (isGlobal && tag[0] != '@')
{
tag = "@" + tag;
}
GannFan gannFan = DrawingTool.GetByTagOrNew(owner, typeof(GannFan), tag, templateName) as GannFan;
if (gannFan == null)
{
return(null);
}
DrawingTool.SetDrawingToolCommonValues(gannFan, tag, isAutoScale, owner, isGlobal);
ChartAnchor anchor = DrawingTool.CreateChartAnchor(owner, barsAgo, time, y);
anchor.CopyDataValues(gannFan.Anchor);
gannFan.SetState(State.Active);
return(gannFan);
}
private static TimeCycles TimeCyclesCore(NinjaScriptBase owner, string tag, int startBarsAgo, int endBarsAgo,
DateTime startTime, DateTime endTime, Brush brush, Brush areaBrush, int areaOpacity, bool isGlobal, string templateName)
{
if (owner == null)
{
throw new ArgumentException("owner");
}
if (string.IsNullOrWhiteSpace(tag))
{
throw new ArgumentException("tag cant be null or empty");
}
if (isGlobal && tag[0] != GlobalDrawingToolManager.GlobalDrawingToolTagPrefix)
{
tag = GlobalDrawingToolManager.GlobalDrawingToolTagPrefix + tag;
}
TimeCycles drawingTool = DrawingTool.GetByTagOrNew(owner, typeof(TimeCycles), tag, templateName) as TimeCycles;
if (drawingTool == null)
{
return(null);
}
if (startTime < Core.Globals.MinDate)
{
throw new ArgumentException(drawingTool + " startTime must be greater than the minimum Date but was " + startTime);
}
else if (endTime < Core.Globals.MinDate)
{
throw new ArgumentException(drawingTool + " endTime must be greater than the minimum Date but was " + endTime);
}
DrawingTool.SetDrawingToolCommonValues(drawingTool, tag, false, owner, isGlobal);
// dont overwrite existing anchor references
ChartAnchor startAnchor = DrawingTool.CreateChartAnchor(owner, startBarsAgo, startTime, 0);
ChartAnchor endAnchor = DrawingTool.CreateChartAnchor(owner, endBarsAgo, endTime, 0);
startAnchor.CopyDataValues(drawingTool.StartAnchor);
endAnchor.CopyDataValues(drawingTool.EndAnchor);
// these can be null when using a templateName so mind not overwriting them
if (brush != null)
{
drawingTool.OutlineStroke = new Stroke(brush, DashStyleHelper.Solid, 2f)
{
RenderTarget = drawingTool.OutlineStroke.RenderTarget
}
}
;
if (areaOpacity >= 0)
{
drawingTool.AreaOpacity = areaOpacity;
}
if (areaBrush != null)
{
drawingTool.AreaBrush = areaBrush.Clone();
if (drawingTool.AreaBrush.CanFreeze)
{
drawingTool.AreaBrush.Freeze();
}
}
drawingTool.SetState(State.Active);
return(drawingTool);
}
public override void OnMouseDown(ChartControl chartControl, ChartPanel chartPanel, ChartScale chartScale, ChartAnchor dataPoint)
{
switch (DrawingState)
{
case DrawingState.Building:
if (Mode == RegionHighlightMode.Price)
{
dataPoint.Time = chartControl.FirstTimePainted.AddSeconds((chartControl.LastTimePainted - chartControl.FirstTimePainted).TotalSeconds / 2);
}
else
{
dataPoint.Price = chartScale.MinValue + (chartScale.MaxMinusMin / 2);
}
if (StartAnchor.IsEditing)
{
dataPoint.CopyDataValues(StartAnchor);
StartAnchor.IsEditing = false;
dataPoint.CopyDataValues(EndAnchor);
}
else if (EndAnchor.IsEditing)
{
if (Mode == RegionHighlightMode.Price)
{
dataPoint.Time = StartAnchor.Time;
dataPoint.SlotIndex = StartAnchor.SlotIndex;
}
else
{
dataPoint.Price = StartAnchor.Price;
}
dataPoint.CopyDataValues(EndAnchor);
EndAnchor.IsEditing = false;
}
if (!StartAnchor.IsEditing && !EndAnchor.IsEditing)
{
DrawingState = DrawingState.Normal;
IsSelected = false;
}
break;
case DrawingState.Normal:
Point point = dataPoint.GetPoint(chartControl, chartPanel, chartScale);
editingAnchor = GetClosestAnchor(chartControl, chartPanel, chartScale, cursorSensitivity, point);
if (editingAnchor != null)
{
editingAnchor.IsEditing = true;
DrawingState = DrawingState.Editing;
}
else
{
if (GetCursor(chartControl, chartPanel, chartScale, point) == Cursors.SizeAll)
{
DrawingState = DrawingState.Moving;
}
else if (GetCursor(chartControl, chartPanel, chartScale, point) == Cursors.SizeWE || GetCursor(chartControl, chartPanel, chartScale, point) == Cursors.SizeNS)
{
DrawingState = DrawingState.Editing;
}
else if (GetCursor(chartControl, chartPanel, chartScale, point) == Cursors.Arrow)
{
DrawingState = DrawingState.Editing;
}
else if (GetCursor(chartControl, chartPanel, chartScale, point) == null)
{
IsSelected = false;
}
}
break;
}
}
public override void OnMouseDown(ChartControl chartControl, ChartPanel chartPanel, ChartScale chartScale, ChartAnchor dataPoint)
{
switch (DrawingState)
{
case DrawingState.Building:
if (StartAnchor.IsEditing)
{
dataPoint.CopyDataValues(StartAnchor);
// Give end anchor something to start with so we dont try to render it with bad values right away
dataPoint.CopyDataValues(EndAnchor);
StartAnchor.IsEditing = false;
}
else if (EndAnchor.IsEditing)
{
dataPoint.CopyDataValues(EndAnchor);
// Give extension anchor something nearby to start with
dataPoint.CopyDataValues(ExtensionAnchor);
EndAnchor.IsEditing = false;
}
else if (ExtensionAnchor.IsEditing)
{
dataPoint.CopyDataValues(ExtensionAnchor);
ExtensionAnchor.IsEditing = false;
}
// Is initial building done (all anchors set)
if (Anchors.All(a => !a.IsEditing))
{
DrawingState = DrawingState.Normal;
IsSelected = false;
}
break;
case DrawingState.Normal:
Point point = dataPoint.GetPoint(chartControl, chartPanel, chartScale);
editingAnchor = GetClosestAnchor(chartControl, chartPanel, chartScale, cursorSensitivity, point);
if (editingAnchor != null)
{
editingAnchor.IsEditing = true;
DrawingState = DrawingState.Editing;
}
else
{
if (GetCursor(chartControl, chartPanel, chartScale, point) == Cursors.SizeAll)
{
DrawingState = DrawingState.Moving;
}
else if (GetCursor(chartControl, chartPanel, chartScale, point) == Cursors.SizeNESW ||
GetCursor(chartControl, chartPanel, chartScale, point) == Cursors.SizeNWSE)
{
DrawingState = DrawingState.Editing;
}
else if (GetCursor(chartControl, chartPanel, chartScale, point) == Cursors.Arrow)
{
DrawingState = DrawingState.Editing;
}
else if (GetCursor(chartControl, chartPanel, chartScale, point) == null)
{
IsSelected = false;
}
}
break;
}
}
public override void OnMouseDown(ChartControl chartControl, ChartPanel chartPanel, ChartScale chartScale, ChartAnchor dataPoint)
{
Point p = dataPoint.GetPoint(chartControl, chartPanel, chartScale);
switch (DrawingState)
{
case DrawingState.Building:
if (ChartAnchors.Count == 0)
{
ChartAnchors.Add(new ChartAnchor {
DisplayName = Custom.Resource.NinjaScriptDrawingToolAnchor, IsEditing = true, DrawingTool = this
});
}
foreach (ChartAnchor ca in ChartAnchors)
{
if (ca.IsEditing)
{
dataPoint.CopyDataValues(ca);
ca.IsEditing = false;
}
}
ChartAnchor clickTestAnchor = GetClosestAnchor(chartControl, chartPanel, chartScale, cursorSensitivity, p);
if (ChartAnchors.Count > 1 && doubleClickTimer.IsEnabled && clickTestAnchor != null && clickTestAnchor != ChartAnchors[ChartAnchors.Count - 1])
{
// ChartAnchors[ChartAnchors.Count - 1] is the 'temp anchor'
ChartAnchors.Remove(ChartAnchors[ChartAnchors.Count - 1]);
PathToolSegments.Remove(PathToolSegments[PathToolSegments.Count - 1]);
doubleClickTimer.Stop();
DrawingState = DrawingState.Normal;
IsSelected = false;
}
else
{
ChartAnchor ca = new ChartAnchor {
DisplayName = Custom.Resource.NinjaScriptDrawingToolAnchor, IsEditing = true, DrawingTool = this
};
dataPoint.CopyDataValues(ca);
ChartAnchors.Add(ca);
if (ChartAnchors.Count > 1)
{
PathToolSegments.Add(new PathToolSegment(ChartAnchors[ChartAnchors.Count - 2], ChartAnchors[ChartAnchors.Count - 1], string.Format("{0} {1}", Custom.Resource.NinjaScriptDrawingToolPathSegment, PathToolSegments.Count + 1)));
if (!doubleClickTimer.IsEnabled)
{
doubleClickTimer.Start();
}
}
}
break;
case DrawingState.Normal:
editingAnchor = GetClosestAnchor(chartControl, chartPanel, chartScale, cursorSensitivity, p);
if (editingAnchor != null)
{
editingAnchor.IsEditing = true;
DrawingState = DrawingState.Editing;
}
else
{
if (GetCursor(chartControl, chartPanel, chartScale, p) != null)
{
DrawingState = DrawingState.Moving;
}
}
break;
}
}
private static RiskReward RiskRewardCore(NinjaScriptBase owner, string tag,
bool isAutoScale,
int entryBarsAgo, DateTime entryTime, double entryY,
int stopBarsAgo, DateTime stopTime, double stopY,
int targetBarsAgo, DateTime targetTime, double targetY,
double ratio, bool isStop, bool isGlobal, string templateName)
{
if (owner == null)
{
throw new ArgumentException("owner");
}
if (entryBarsAgo == int.MinValue && entryTime == Core.Globals.MinDate)
{
throw new ArgumentException("entry value required");
}
if (stopBarsAgo == int.MinValue && stopTime == Core.Globals.MinDate &&
targetBarsAgo == int.MinValue && targetTime == Core.Globals.MinDate)
{
throw new ArgumentException("a stop or target value is required");
}
if (isGlobal && tag[0] != GlobalDrawingToolManager.GlobalDrawingToolTagPrefix)
{
tag = string.Format("{0}{1}", GlobalDrawingToolManager.GlobalDrawingToolTagPrefix, tag);
}
RiskReward riskReward = DrawingTool.GetByTagOrNew(owner, typeof(RiskReward), tag, templateName) as RiskReward;
if (riskReward == null)
{
return(null);
}
DrawingTool.SetDrawingToolCommonValues(riskReward, tag, isAutoScale, owner, isGlobal);
// this is a little tricky, we use entry + (stop or target) to calculate the (target or stop) from ratio
ChartAnchor entryAnchor = DrawingTool.CreateChartAnchor(owner, entryBarsAgo, entryTime, entryY);
ChartAnchor stopAnchor;
ChartAnchor targetAnchor;
double yDiff;
if (isStop)
{
stopAnchor = DrawingTool.CreateChartAnchor(owner, stopBarsAgo, stopTime, stopY);
yDiff = entryY - stopY;
targetAnchor = new ChartAnchor();
// copy entry to target so x aligned, then adjust y by our ratio
entryAnchor.CopyDataValues(targetAnchor);
targetAnchor.Price = entryY + yDiff * ratio;
}
else
{
targetAnchor = DrawingTool.CreateChartAnchor(owner, targetBarsAgo, targetTime, targetY);
yDiff = entryY - targetY;
stopAnchor = new ChartAnchor();
// copy entry to stop so x aligned, then adjust y by our ratio
entryAnchor.CopyDataValues(stopAnchor);
stopAnchor.Price = entryY + yDiff / ratio;
}
entryAnchor.CopyDataValues(riskReward.EntryAnchor);
stopAnchor.CopyDataValues(riskReward.RiskAnchor);
targetAnchor.CopyDataValues(riskReward.RewardAnchor);
riskReward.SetState(State.Active);
return(riskReward);
}
public override void OnMouseDown(ChartControl chartControl, ChartPanel chartPanel, ChartScale chartScale, ChartAnchor dataPoint)
{
if (IsButtonCLick)
{
IsButtonCLick = false;
return;
}
switch (DrawingState)
{
case DrawingState.Building:
if (StartAnchor.IsEditing)
{
dataPoint.CopyDataValues(StartAnchor);
StartAnchor.IsEditing = false;
// give end anchor something to start with so we dont try to render it with bad values right away
dataPoint.CopyDataValues(EndAnchor);
}
else if (EndAnchor.IsEditing)
{
dataPoint.CopyDataValues(EndAnchor);
EndAnchor.IsEditing = false;
}
// is initial building done (both anchors set)
if (!StartAnchor.IsEditing && !EndAnchor.IsEditing)
{
DrawingState = DrawingState.Normal;
IsSelected = false;
}
break;
case DrawingState.Normal:
Point point = dataPoint.GetPoint(chartControl, chartPanel, chartScale);
// see if they clicked near a point to edit, if so start editing
editingAnchor = GetClosestAnchor(chartControl, chartPanel, chartScale, cursorSensitivity, point);
if (editingAnchor != null)
{
editingAnchor.IsEditing = true;
DrawingState = DrawingState.Editing;
}
else
{
if (GetCursor(chartControl, chartPanel, chartScale, point) != null)
{
DrawingState = DrawingState.Moving;
}
else
{
// user whiffed.
int start_X = ((int)model.parent.ChartControl.GetXByTime(StartAnchor.Time));
int end_X = ((int)model.parent.ChartControl.GetXByTime(EndAnchor.Time));
int start_Y = chartScale.GetYByValue(StartAnchor.Price);
int end_Y = chartScale.GetYByValue(EndAnchor.Price);
int leftPosition = 0;
int topPosition = 0;
if (start_X < end_X)
{
leftPosition = start_X;
}
else
{
leftPosition = end_X;
}
if (start_Y < end_Y)
{
topPosition = start_Y;
}
else
{
topPosition = end_Y;
}
if (point.X >= leftPosition && point.X <= leftPosition + 15 && point.Y >= topPosition - 20 && point.Y <= topPosition - 5)
{
model.parent.RemoveDrawObject(this.Tag);
model.DeleteProfile(this.Tag);
model.SaveProfiles();
IsButtonCLick = true;
break;
}
if (point.X >= leftPosition + 20 && point.X <= leftPosition + 20 + 15 && point.Y >= topPosition - 20 && point.Y <= topPosition - 5)
{
if (ProfileType == 0)
{
ProfileType = 1;
}
else if (ProfileType == 1)
{
ProfileType = 2;
}
else if (ProfileType == 2)
{
ProfileType = 0;
}
model.SaveProfiles();
IsButtonCLick = true;
break;
}
if (point.X >= leftPosition + 40 && point.X <= leftPosition + 40 + 15 && point.Y >= topPosition - 20 && point.Y <= topPosition - 5)
{
ExtendedLine = !ExtendedLine;
model.SaveProfiles();
IsButtonCLick = true;
break;
}
IsSelected = false;
}
}
break;
}
/*Point point1 = dataPoint.GetPoint(chartControl, chartPanel, chartScale);
*
*/
}
public override void OnMouseDown(ChartControl chartControl, ChartPanel chartPanel, ChartScale chartScale, ChartAnchor dataPoint)
{
Point p = dataPoint.GetPoint(chartControl, chartPanel, chartScale);
switch (DrawingState)
{
case DrawingState.Building:
if (ChartAnchors.Count == 0)
{
ChartAnchors.Add(new ChartAnchor {
DisplayName = Custom.Resource.NinjaScriptDrawingToolAnchor, IsEditing = true, DrawingTool = this
});
}
foreach (ChartAnchor ca in ChartAnchors)
{
if (ca.IsEditing)
{
dataPoint.CopyDataValues(ca);
ca.IsEditing = false;
}
}
if (ChartAnchors.Count > 2 && (GetCursor(chartControl, chartPanel, chartScale, p) == Cursors.Cross || DateTime.Now.Subtract(lastClick).TotalMilliseconds <= 200))
{
ChartAnchors.Remove(ChartAnchors[ChartAnchors.Count - 1]);
DrawingState = DrawingState.Normal;
IsSelected = false;
}
else
{
ChartAnchor ca = new ChartAnchor {
DisplayName = Custom.Resource.NinjaScriptDrawingToolAnchor, IsEditing = true, DrawingTool = this
};
dataPoint.CopyDataValues(ca);
ChartAnchors.Add(ca);
}
lastClick = DateTime.Now;
break;
case DrawingState.Normal:
editingAnchor = GetClosestAnchor(chartControl, chartPanel, chartScale, cursorSensitivity, p);
if (editingAnchor != null)
{
editingAnchor.IsEditing = true;
DrawingState = DrawingState.Editing;
}
else
{
if (GetCursor(chartControl, chartPanel, chartScale, p) != null)
{
DrawingState = DrawingState.Moving;
}
else if (!IsPointInsidePolygon(chartControl, chartPanel, chartScale, p))
{
IsSelected = false;
}
}
break;
}
}
private static Text TextCore(NinjaScriptBase owner, string tag, bool autoScale, string text,
int barsAgo, DateTime time, double y, int?yPixelOffset, Brush textBrush, TextAlignment?textAlignment,
Gui.Tools.SimpleFont font, Brush outlineBrush, Brush areaBrush, int?areaOpacity, bool isGlobal, string templateName,
DashStyleHelper outlineDashStyle, int outlineWidth)
{
if (barsAgo == int.MinValue && time == Core.Globals.MinDate)
{
throw new ArgumentException("Text: Bad barsAgo/time parameters");
}
if (string.IsNullOrWhiteSpace(tag))
{
throw new ArgumentException(@"tag cant be null or empty", "tag");
}
if (isGlobal && tag[0] != GlobalDrawingToolManager.GlobalDrawingToolTagPrefix)
{
tag = GlobalDrawingToolManager.GlobalDrawingToolTagPrefix + tag;
}
Text txt = DrawingTool.GetByTagOrNew(owner, typeof(Text), tag, templateName) as Text;
if (txt == null)
{
return(null);
}
DrawingTool.SetDrawingToolCommonValues(txt, tag, autoScale, owner, isGlobal);
ChartAnchor anchor = DrawingTool.CreateChartAnchor(owner, barsAgo, time, y);
anchor.CopyDataValues(txt.Anchor);
// set defaults, then apply ns properties so they dont get trampled
txt.SetState(State.Active);
txt.DisplayText = text;
if (textBrush != null)
{
txt.TextBrush = textBrush;
}
if (txt.TextBrush == null)
{
txt.UseChartTextBrush = true;
}
if (textAlignment != null)
{
txt.Alignment = textAlignment.Value;
}
else if (string.IsNullOrEmpty(templateName))
{
txt.Alignment = TextAlignment.Center;
}
if (outlineBrush != null)
{
txt.OutlineStroke = new Stroke(outlineBrush, outlineDashStyle, outlineWidth)
{
RenderTarget = txt.OutlineStroke.RenderTarget
}
}
;
if (areaBrush != null)
{
txt.AreaBrush = areaBrush;
}
if (areaOpacity != null)
{
txt.AreaOpacity = areaOpacity.Value;
}
if (font != null)
{
txt.Font = font.Clone() as Gui.Tools.SimpleFont;
}
if (yPixelOffset != null)
{
txt.YPixelOffset = yPixelOffset.Value;
}
return(txt);
}
public override void OnMouseDown(ChartControl chartControl, ChartPanel chartPanel, ChartScale chartScale, ChartAnchor dataPoint)
{
if (DrawingState == DrawingState.Building)
{
dataPoint.CopyDataValues(Anchor);
Anchor.IsEditing = false;
DisplayText = string.Empty;
TextBox tb = new TextBox
{
AcceptsReturn = true,
Background = new SolidColorBrush(Color.FromArgb(4, 0, 0, 0)),
BorderBrush = chartControl.Properties.AxisPen.Brush,
FontFamily = Font.Family,
FontSize = Font.Size,
FontStyle = Font.Italic ? FontStyles.Italic : FontStyles.Normal,
FontWeight = Font.Bold ? FontWeights.Bold : FontWeights.Normal,
Foreground = TextBrush ?? chartControl.Properties.ChartText,
HorizontalAlignment = HorizontalAlignment.Stretch,
Style = Application.Current.FindResource("TextBoxNoEffects") as Style
};
if (TextBrush == null)
{
UseChartTextBrush = true;
}
popup = new Popup
{
AllowsTransparency = true,
PlacementTarget = chartPanel,
Placement = PlacementMode.MousePoint,
MinWidth = 75,
IsOpen = false,
StaysOpen = false,
Child = tb
};
tb.PreviewKeyDown += (sender, args) =>
{
if (args.Key == Key.System && args.SystemKey == Key.Enter)
{
int oldIdx = tb.CaretIndex;
string text1 = tb.Text.Substring(0, oldIdx);
string text2 = tb.Text.Substring(oldIdx);
tb.Text = string.Format("{0}{1}{2}", text1, Environment.NewLine, text2);
tb.CaretIndex = oldIdx + Environment.NewLine.Length;
args.Handled = true;
}
if (args.Key == Key.Enter)
{
popup.IsOpen = false;
args.Handled = true;
}
};
tb.PreviewLostKeyboardFocus += (sender, args) => { popup.IsOpen = false; };
popup.IsOpen = true;
ManuallyDrawn = true;
tb.Focus();
chartControl.OwnerChart.PreviewMouseDown += OnChartMouseDown;
popup.Closed += (sender, args) =>
{
chartControl.OwnerChart.PreviewMouseDown -= OnChartMouseDown;
DisplayText = tb.Text;
DrawingState = DrawingState.Normal;
IsSelected = false;
chartControl.InvalidateVisual();
if (chartControl.IsStayInDrawMode)
{
chartControl.TryStartDrawing(GetType().FullName);
}
};
}
else
{
Point point = dataPoint.GetPoint(chartControl, chartPanel, chartScale);
if (GetCurrentRect(layoutRect, outlinePadding).IntersectsWith(new Rect(point.X, point.Y, 2, 2)))
{
Anchor.IsEditing = true;
DrawingState = DrawingState.Moving;
}
else
{
IsSelected = false;
}
}
}
public override void OnMouseDown(ChartControl chartControl, ChartPanel chartPanel, ChartScale chartScale, ChartAnchor dataPoint)
{
switch (DrawingState)
{
case DrawingState.Building:
if (StartAnchor.IsEditing)
{
dataPoint.CopyDataValues(StartAnchor);
// give end anchor something to start with so we dont try to render it with bad values right away
dataPoint.CopyDataValues(EndAnchor);
dataPoint.CopyDataValues(TextAnchor);
StartAnchor.IsEditing = false;
}
else if (EndAnchor.IsEditing)
{
dataPoint.CopyDataValues(EndAnchor);
EndAnchor.IsEditing = false;
// give text anchor something to start with right away so we dont try to render it
// with uninitialized values as well
dataPoint.CopyDataValues(TextAnchor);
}
else if (TextAnchor.IsEditing)
{
dataPoint.CopyDataValues(TextAnchor);
TextAnchor.IsEditing = false;
}
// is initial building done (all anchors set)
if (!StartAnchor.IsEditing && !EndAnchor.IsEditing && !TextAnchor.IsEditing)
{
DrawingState = DrawingState.Normal;
IsSelected = false;
}
break;
case DrawingState.Normal:
Point point = dataPoint.GetPoint(chartControl, chartPanel, chartScale);
// see if they clicked near a point to edit, if so start editing
editingAnchor = GetClosestAnchor(chartControl, chartPanel, chartScale, cursorSensitivity, point);
if (editingAnchor != null)
{
editingAnchor.IsEditing = true;
DrawingState = DrawingState.Editing;
}
else if (editingAnchor == null || IsLocked)
{
// or if they didnt click particulary close to either, move (they still clicked close to our line)
// set it to moving even if locked so we know to change cursor
if (GetCursor(chartControl, chartPanel, chartScale, point) != null)
{
DrawingState = DrawingState.Moving;
}
else
{
IsSelected = false;
}
}
break;
}
}
