//Remove the binding target
void output_ControlPointRemoved(BasicControlPoint cp, IControlPoint other)
{
if (other.Virtual == true)
{
return;
}
TriggersTemplateOutputActionBinder outputBinder = mOutputActionCPs[cp];
TriggerBindInfo toremove = null;
foreach (TriggerBindInfo b in outputBinder.TargetIDs)
{
if (b != null && other != null)
{
if (b.LinkName == other.ToString())
{
toremove = b;
}
}
else
{
CoreGlobals.getErrorManager().LogErrorToNetwork("(b.LinkName == other.ToString())");
}
}
if (toremove != null)
{
outputBinder.TargetIDs.Remove(toremove);
}
}
public void DisconnectControlPoint(IControlPoint cpTarget)
{
if (GetTargets().Contains(cpTarget))
{
//Recursive removal of chained control points
//if (cpTarget.ChainChild != null)
//{
// foreach(IControlPoint subtarget in cpTarget.ChainChild.GetTargets())
// {
// //this.DisconnectControlPoint(subtarget);
// //cpTarget.ChainChild.DisconnectControlPoint(subtarget);
// }
//}
//IControlPoint chainStart = cpTarget.ChainChild
//Remove the actual target
GetTargets().Remove(cpTarget);
if (ControlPointRemoved != null)
{
ControlPointRemoved.Invoke(this, cpTarget);
}
BasicControlPoint target = cpTarget as BasicControlPoint;
if (target.SenderControlPointRemoved != null && target != null)
{
target.SenderControlPointRemoved.Invoke(target, this);
}
}
}
/// <summary>
/// Validates the curve</summary>
/// <param name="curve">Curve to validate</param>
/// <returns>True iff curve is valid</returns>
public static bool IsValid(ICurve curve)
{
if (curve == null)
{
return(false);
}
ReadOnlyCollection <IControlPoint> points = curve.ControlPoints;
if (points.Count < 2)
{
return(true);
}
int count = points.Count;
IControlPoint prev = points[0];
for (int i = 1; i < count; i++)
{
IControlPoint curPoint = points[i];
if ((curPoint.X - prev.X) < s_epsilone)
{
return(false);
}
prev = curPoint;
}
return(true);
}
private void ComputeHermiteCoeff(IControlPoint p1, IControlPoint p2, float[] Coeff)
{
Vec2F t1 = new Vec2F(p1.TangentOut.X, p1.TangentOut.Y);
Vec2F t2 = new Vec2F(p2.TangentIn.X, p2.TangentIn.Y);
float m1 = 0.0f;
if (t1.X != 0.0f)
{
m1 = t1.Y / t1.X;
}
float m2 = 0.0f;
if (t2.X != 0.0f)
{
m2 = t2.Y / t2.X;
}
float dx = p2.X - p1.X;
float dy = p2.Y - p1.Y;
float length = 1.0f / (dx * dx);
float d1 = dx * m1;
float d2 = dx * m2;
Coeff[0] = (d1 + d2 - dy - dy) * length / dx;
Coeff[1] = (dy + dy + dy - d1 - d1 - d2) * length;
Coeff[2] = m1;
Coeff[3] = p1.Y;
}
/// <summary>
/// Gets valid insertion index at x for curve</summary>
/// <param name="curve">Curve</param>
/// <param name="x">X coordinate</param>
/// <returns>Valid insertion index at x for curve</returns>
public static int GetValidInsertionIndex(ICurve curve, float x)
{
ReadOnlyCollection <IControlPoint> points = curve.ControlPoints;
if (points.Count == 0)
{
return(0);
}
IControlPoint last = points[points.Count - 1];
if ((x - last.X) > s_epsilone)
{
return(points.Count);
}
for (int i = 0; i < points.Count; i++)
{
IControlPoint p = points[i];
if ((x - p.X) < -s_epsilone)
{
return(i);
}
if ((x - p.X) > s_epsilone)
{
continue;
}
else
{
return(-1);
}
}
return(points.Count);
}
// GroupInputHardPointsBar
IControlPoint GetExternalInputControlPoint(IControlPoint originalSender)
{
if (mInputControlPointMap.ContainsKey(originalSender) == false)
{
BasicControlPoint proxy = new BasicControlPoint(mOuterGroup);
//proxy.mbDontHide = true;
proxy.Virtual = true;
proxy.SetDirection(new Point(250, 0));
proxy.TargetKey = originalSender.TargetKey;
proxy.TypeKey = originalSender.TypeKey;
//proxy.BackColor = originalSender.BackColor;
proxy.TagObject = this;
proxy.ControlPointDescription = proxy.ControlPointDescription;
proxy.ProxyTarget = originalSender;
mControlPoints.Add(proxy);
GroupInputHardPointsBar.AddControl(proxy);
mInputControlPointMap[originalSender] = proxy;
proxy.ControlPointConnected += new BasicControlPoint.ControlPointEvent(inproxy_ControlPointConnected);
proxy.ControlPointRemoved += new BasicControlPoint.ControlPointEvent(inproxy_ControlPointRemoved);
}
return(mInputControlPointMap[originalSender]);
}
/// <summary>
/// Compute tangents for all control points in a given curve</summary>
/// <param name="curve">Curve</param>
public static void ComputeTangent(ICurve curve)
{
if (curve == null)
{
return;
}
ReadOnlyCollection <IControlPoint> points = curve.ControlPoints;
if (points.Count == 0)
{
return;
}
if (points.Count == 1)
{
Vec2F tan = new Vec2F(1, 0);
IControlPoint pt = points[0];
if (pt.TangentIn != tan)
{
pt.TangentIn = tan;
}
if (pt.TangentOut != tan)
{
pt.TangentOut = tan;
}
return;
}
for (int i = 0; i < points.Count; i++)
{
ComputeTangentIn(curve, i);
ComputeTangentOut(curve, i);
}
}
IControlPoint GetExternalOutputControlPoint(IControlPoint originalSender, IControlPoint originalTarget)
{
if (mOutputControlPointMap.ContainsKey(originalTarget) == false)
{
originalTarget.HasProxy = true;
BasicControlPoint proxy = new BasicControlPoint(mOuterGroup);
proxy.Virtual = true;
proxy.SetDirection(new Point(-250, 0));
//proxy.ChainChild = target;
proxy.TargetKey = originalTarget.TargetKey;
proxy.TypeKey = originalTarget.TypeKey;
//proxy.BackColor = originalSender.BackColor;
proxy.ControlPointDescription = originalTarget.ControlPointDescription;
proxy.Name = originalTarget.ToString();
proxy.TagObject = this;
proxy.ProxyTarget = originalTarget;
mControlPoints.Add(proxy); //?
GroupOutputHardPointsBar.AddControl(proxy);
mOutputControlPointMap[originalTarget] = proxy;
proxy.SenderControlPointConnected += new BasicControlPoint.ControlPointEvent(outproxy_ControlPointConnected);
proxy.SenderControlPointRemoved += new BasicControlPoint.ControlPointEvent(outproxy_ControlPointRemoved);
}
return(mOutputControlPointMap[originalTarget]);
}
/// <summary>
/// Determines if given control point's x coordinate is in sorted order</summary>
/// <param name="cp">Control point</param>
/// <returns>True iff control point's x coordinate is in sorted order</returns>
public static bool IsSorted(IControlPoint cp)
{
bool valid = true;
ICurve curve = cp.Parent;
int index = curve.ControlPoints.IndexOf(cp);
if (index == -1)
{
throw new ArgumentException("cp not found in parent curve");
}
int lastIndex = curve.ControlPoints.Count - 1;
if (index < lastIndex)
{
IControlPoint nextcp = curve.ControlPoints[index + 1];
if (cp.X > nextcp.X)
{
valid = false;
}
}
if (valid && index > 0)
{
IControlPoint prevCp = curve.ControlPoints[index - 1];
if (cp.X < prevCp.X)
{
valid = false;
}
}
return(valid);
}
void l_DragDrop(object sender, DragEventArgs e)
{
Label l = sender as Label;
//object data = e.Data.GetData(typeof(TriggerParameterControl));
//TriggerParameterControl otherButton = data as TriggerParameterControl;
//if (otherButton != null)
//{
// TriggerVariable ctrlMove = otherButton.GetVariable();// as TriggerVariable;
// if (e.Effect == DragDropEffects.Move)
// {
// if (otherButton.ParameterMode == TriggerParameterControl.eParameterMode.Const)
// {
// PresentationValue = ctrlMove.ID;
// l.Text = mTriggerNamespace.GetValues()[ctrlMove.ID].Value;
// }
// else
// {
// PresentationValue = ctrlMove.ID;
// l.Text = ctrlMove.Name;
// l.Refresh();
// }
// //UpdateControl();
// }
//}
string[] formats = e.Data.GetFormats();
if (formats.Length == 0)
{
return;
}
IControlPoint otherControlPoint = e.Data.GetData(e.Data.GetFormats()[0]) as IControlPoint;
if (otherControlPoint != null)
{
if (e.Effect == DragDropEffects.Link)
{
string key = otherControlPoint.ToString();
string id = otherControlPoint.TagObject.ToString();
string link = string.Format("{0},{1}", id, key);
this.PresentationValue = link;
l.Text = link;
l.ForeColor = Color.Blue;
l.Refresh();
//if (otherControlPoint.CanConnect(this))
//{
// otherControlPoint.ConnectControlPoint(this);
//}
//else if (this.CanConnect(otherControlPoint))
//{
// ConnectControlPoint(otherControlPoint);
//}
//mHost.SetDirty();
}
}
}
private static async Task StartControlPointListeningAsync()
{
_controlPoint = new ControlPoint(_httpListener);
await ListenToNotify();
await ListenToMSearchResponse();
}
void deleteConnection_Click(object sender, EventArgs e)
{
MenuItem m = sender as MenuItem;
IControlPoint cp = m.Tag as IControlPoint;
this.DisconnectControlPoint(cp);
mHost.SetDirty();
}
/// <summary>
/// Creates a control point</summary>
/// <returns>Control point</returns>
public IControlPoint CreateControlPoint()
{
DomNode node = new DomNode(Schema.controlPointType.Type);
node.InitializeExtensions();
IControlPoint cpt = node.As <IControlPoint>();
cpt.Name = "ControlPoint";
return(cpt);
}
bool ValidateConnection(IControlPoint otherControlPoint)
{
if (otherControlPoint != null)
{
if (otherControlPoint.CanConnect(this) || this.CanConnect(otherControlPoint))
{
return(true);
}
}
return(false);
}
void outproxy_ControlPointRemoved(BasicControlPoint cp, IControlPoint other)
{
if (!cp.MarkForDelete && !mbLoading)
{
other.DisconnectControlPoint(cp.ProxyTarget);
}
if (!cp.MarkForDelete && !mbLoading)
{
mHost.UIUpdate(mGroupUI, new BasicArgument(BasicArgument.eArgumentType.Refresh), eUpdateVisibilty.AnyVisiblity);
}
mHost.SetGroupsDirty();
}
private static async Task StartControlPointListeningAsync(CancellationToken ct)
{
_controlPoint = new ControlPoint(_controlPointLocalIp1);
_controlPoint.Start(ct);
ListenToMSearchResponse(ct);
ListenToNotify();
await StartMSearchRequestMulticastAsync();
}
/// <summary>
/// Creates a control point</summary>
/// <returns>Control point</returns>
public IControlPoint CreateControlPoint()
{
DomNode node = new DomNode(UISchema.controlPointType.Type);
node.InitializeExtensions();
IControlPoint cpt = node.As <IControlPoint>();
cpt.TangentInType = CurveTangentTypes.Spline;
cpt.TangentIn = new Vec2F(0.5f, 0.5f);
cpt.TangentOutType = CurveTangentTypes.Spline;
cpt.TangentOut = new Vec2F(0.5f, 0.5f);
return(cpt);
}
/// <summary>
/// Add a new binding target
/// </summary>
/// <param name="cp">This(starting) control point</param>
/// <param name="other">Target control point</param>
void output_ControlPointConnected(BasicControlPoint cp, IControlPoint other)
{
if (other.Virtual == true)
{
return;
}
//set target value:
TriggerControl t = other.TagObject as TriggerControl;
TriggersTemplateOutputActionBinder outputbinder = mOutputActionCPs[cp];
if (t != null)
{
string name = cp.ToString();
if (mOutputActionCPs.ContainsKey(cp))
{
TriggerBindInfo bindInfo = new TriggerBindInfo();
bindInfo.SetTarget(t.Trigger.ID, other.ToString());
outputbinder.TargetIDs.Add(bindInfo);
return;
}
}
TemplateControl templateControl = other.TagObject as TemplateControl;
if (templateControl != null)
{
string name = other.ToString();
foreach (TriggersTemplateInputActionBinder inputBinder in templateControl.TriggerTemplateMapping.TriggerInputs)
{
if (inputBinder.Name == name)
{
foreach (TriggerBindInfo b in inputBinder.TargetIDs)
{
if (b.ID == templateControl.TriggerTemplateMapping.ID && b.LinkName == other.ToString())
{
CoreGlobals.getErrorManager().OnSimpleWarning("can't bind. template is already bound to trigger. this is a bug");
return;
}
}
TriggerBindInfo bindInfo = new TriggerBindInfo();
bindInfo.SetTarget(templateControl.TriggerTemplateMapping.ID, other.ToString());
outputbinder.TargetIDs.Add(bindInfo);
return;
}
}
}
}
void BasicControlPoint_DragDrop(object sender, DragEventArgs e)
{
string[] formats = e.Data.GetFormats();
if (formats.Length == 0)
{
return;
}
IControlPoint otherControlPoint = e.Data.GetData(e.Data.GetFormats()[0]) as IControlPoint;
if (e.Effect == DragDropEffects.Link)
{
BindControlPoints(otherControlPoint);
}
}
/// <summary>
/// Sort control points along x axis</summary>
/// <param name="curve">Curve whose control points are sorted</param>
public static void Sort(ICurve curve)
{
if (curve == null)
{
return;
}
ReadOnlyCollection <IControlPoint> points = curve.ControlPoints;
if (points.Count < 2)
{
return;
}
try
{
s_points.Clear();
s_points.AddRange(points);
// note about "insertion sort"
// this type of sort is most efficient for Substantially sorted data
// in this case the data is Substantially sorted, only few elements need fixing.
for (int i = 1; i < s_points.Count; i++)
{
IControlPoint val = s_points[i];
int j = i - 1;
while (j >= 0 && s_points[j].X > val.X)
{
s_points[j + 1] = s_points[j];
j--;
}
s_points[j + 1] = val;
}
for (int i = 0; i < s_points.Count; i++)
{
IControlPoint scpt = s_points[i];
IControlPoint cpt = points[i];
if (scpt != cpt)
{
curve.InsertControlPoint(i, scpt);
}
}
}
finally
{
s_points.Clear();
}
}
/// <summary>
/// Create and add new control point to the given curve at a given Vec2F gpt</summary>
/// <param name="curve">Curve to modify</param>
/// <param name="gpt">Location on the x-axis at which to add a control point. Whether
/// or not the y-coordinate is used depends on 'insert' parameter.</param>
/// <param name="insert">If true, the y-value is inserted on the existing curve, using
/// curve.Evaluate(gpt.X). If false, the y-value comes from gpt.Y.</param>
/// <param name="computeTangent">Whether ComputeTangent() should be called</param>
public static void AddControlPoint(ICurve curve, Vec2F gpt, bool insert, bool computeTangent)
{
if (curve == null)
{
throw new ArgumentNullException("curve");
}
// add/insert new control point to the given curve. Using the following rules.
// if adding then add the point at gpt and set is tangent type to spline.
// if inserting then add the point at (gpt.x,curve.eval(gpt.x)) and compute its tangent at the point.
// recompute tangents for the curve.
// find insersion index.
int index = GetValidInsertionIndex(curve, gpt.X);
if (index >= 0)
{
IControlPoint p = curve.CreateControlPoint();
p.EditorData.SelectedRegion = PointSelectionRegions.None;
if (insert)
{
p.X = gpt.X;
ICurveEvaluator cv = CurveUtils.CreateCurveEvaluator(curve);
float prevY = cv.Evaluate(gpt.X - s_epsilone);
float nextY = cv.Evaluate(gpt.X + s_epsilone);
p.Y = cv.Evaluate(gpt.X);
p.TangentInType = CurveTangentTypes.Fixed;
p.TangentOutType = CurveTangentTypes.Fixed;
Vec2F tanIn = new Vec2F(s_epsilone, p.Y - prevY);
tanIn.Normalize();
Vec2F tanOut = new Vec2F(s_epsilone, nextY - p.Y);
tanOut.Normalize();
p.TangentIn = tanIn;
p.TangentOut = tanOut;
}
else
{
p.X = gpt.X;
p.Y = gpt.Y;
p.TangentInType = CurveTangentTypes.Spline;
p.TangentOutType = CurveTangentTypes.Spline;
}
curve.InsertControlPoint(index, p);
if (computeTangent)
{
ComputeTangent(curve);
}
}
}
/// <summary>
/// Computes indices for pre-last and post-first points on the left and right of the
/// viewing rectangle.
/// Set lIndex to -1 and rIndex to -2 to indicate that curve is completely panned
/// either to left or right of the viewing rectangle.
/// This method is used by picking and rendering.</summary>
/// <param name="curve">Curve</param>
/// <param name="lIndex">Left index</param>
/// <param name="rIndex">Right index</param>
private void ComputeIndices(ICurve curve, out int lIndex, out int rIndex)
{
lIndex = -1;
rIndex = -2;
ReadOnlyCollection <IControlPoint> points = curve.ControlPoints;
if (points.Count == 0)
{
return;
}
float leftgx = m_canvas.ClientToGraph(0.0f);
float rightgx = m_canvas.ClientToGraph(m_canvas.ClientSize.Width);
if (points[0].X >= rightgx)
{
return;
}
if (points[points.Count - 1].X <= leftgx)
{
return;
}
// find the index of the control point that
// comes before the first visible control-point from left.
for (int i = (points.Count - 1); i >= 0; i--)
{
IControlPoint cp = points[i];
lIndex = i;
if (cp.X < leftgx)
{
break;
}
}
// find the index of the control-point that comes after last visible control-point
// from right.
for (int i = lIndex; i < points.Count; i++)
{
IControlPoint cp = points[i];
rIndex = i;
if (cp.X > rightgx)
{
break;
}
}
}
void BindControlPoints(IControlPoint otherControlPoint)
{
if (otherControlPoint != null)
{
if (otherControlPoint.CanConnect(this))
{
otherControlPoint.ConnectControlPoint(this);
}
else if (this.CanConnect(otherControlPoint))
{
ConnectControlPoint(otherControlPoint);
}
mHost.SetDirty();
}
}
void inproxy_ControlPointConnected(BasicControlPoint cp, IControlPoint other)
{
if (!cp.MarkForDelete && !mbLoading)
{
if (cp.ProxyTarget.CanConnect(other))
{
cp.ProxyTarget.ConnectControlPoint(other);
}
}
if (!cp.MarkForDelete && !mbLoading)
{
mHost.UIUpdate(mGroupUI, new BasicArgument(BasicArgument.eArgumentType.Refresh), eUpdateVisibilty.AnyVisiblity);
}
mHost.SetGroupsDirty();
}
public bool CanConnect(IControlPoint cpother)
{
if (GetTargets().Contains(cpother) == true)
{
return(false);
}
if (cpother.TypeKey == "none" || this.TargetKey == "none")
{
return(false);
}
if (cpother.TypeKey == this.TargetKey)
{
return(true);
}
return(false);
}
public void ConnectControlPoint(IControlPoint cpTarget)
{
if (CanConnect(cpTarget))
{
GetTargets().Add(cpTarget);
if (ControlPointConnected != null)
{
ControlPointConnected.Invoke(this, cpTarget);
}
BasicControlPoint target = cpTarget as BasicControlPoint;
if (target.SenderControlPointConnected != null && target != null)
{
target.SenderControlPointConnected.Invoke(target, this);
}
}
}
/// <summary>
/// Draws single control point</summary>
/// <param name="prevTanType">Previous CurveTangentTypes</param>
/// <param name="cp">Control point</param>
/// <param name="g">Graphics object</param>
private void DrawControlPoint(CurveTangentTypes prevTanType, IControlPoint cp, Graphics g)
{
Vec2F p = m_canvas.GraphToClient(cp.X, cp.Y);
PointSelectionRegions region = cp.EditorData.SelectedRegion;
if (region != PointSelectionRegions.None)
{
if (prevTanType != CurveTangentTypes.Stepped && prevTanType != CurveTangentTypes.SteppedNext)
{
Vec2F tangIn = Vec2F.Normalize(m_canvas.GraphToClientTangent(cp.TangentIn));
tangIn.X = -tangIn.X;
tangIn.Y = -tangIn.Y;
Color color = region == PointSelectionRegions.TangentIn?
SelectedTangentColor :
cp.BrokenTangents ? TangentInColor : TangentColor;
DrawArrow(p, p + tangIn * m_tangentLength, g, color);
}
if (cp.TangentOutType != CurveTangentTypes.Stepped && cp.TangentOutType != CurveTangentTypes.SteppedNext)
{
Color color = region == PointSelectionRegions.TangentOut ?
SelectedTangentColor : cp.BrokenTangents ? TangentOutColor : TangentColor;
Vec2F tangOut = Vec2F.Normalize(m_canvas.GraphToClientTangent(cp.TangentOut));
DrawArrow(p, p + tangOut * m_tangentLength, g, color);
}
}
RectangleF pointRect = new RectangleF();
float halfPointSize = m_pointSize / 2;
pointRect.X = p.X - halfPointSize;
pointRect.Y = p.Y - halfPointSize;
pointRect.Width = m_pointSize;
pointRect.Height = m_pointSize;
if (region == PointSelectionRegions.Point)
{
g.FillRectangle(m_pointHiBrush, pointRect);
}
else
{
g.FillRectangle(m_pointBrush, pointRect);
}
}
void l_DragEnter(object sender, DragEventArgs e)
{
string[] formats = e.Data.GetFormats();
if (formats.Length == 0)
{
return;
}
IControlPoint otherControlPoint = e.Data.GetData(e.Data.GetFormats()[0]) as IControlPoint;
e.Effect = DragDropEffects.None;
if (otherControlPoint == this)
{
return;
}
if (otherControlPoint != null)
{
//if (otherControlPoint.CanConnect(this) || this.CanConnect(otherControlPoint))
{
e.Effect = DragDropEffects.Link;
}
}
//e.Effect = DragDropEffects.None;
//if (e.Data.GetDataPresent(typeof(TriggerParameterControl)))
//{
// object data = e.Data.GetData(typeof(TriggerParameterControl));
// TriggerParameterControl otherButton = data as TriggerParameterControl;
// if (otherButton != null)
// {
// //TriggerValue ctrlMove = otherButton.mValue as TriggerValue;
// //TriggerValue ctrlTarget = this.mValue as TriggerValue;
// //if (ctrlMove.Type == ctrlTarget.Type)
// e.Effect = DragDropEffects.Move;
// }
//}
}
void BasicControlPoint_DragEnter(object sender, DragEventArgs e)
{
string[] formats = e.Data.GetFormats();
if (formats.Length == 0)
{
return;
}
IControlPoint otherControlPoint = e.Data.GetData(e.Data.GetFormats()[0]) as IControlPoint;
e.Effect = DragDropEffects.None;
if (otherControlPoint == this)
{
return;
}
if (ValidateConnection(otherControlPoint))
{
e.Effect = DragDropEffects.Link;
}
}
protected override void OnNodeSet()
{
base.OnNodeSet();
if (ControlPoints.Count == 0)
{
IControlPoint p0 = CreateControlPoint();
p0.Translation = new Vec3F(-1f, 0, 0);
ControlPoints.Add(p0);
}
if (ControlPoints.Count < 2)
{
IControlPoint p1 = CreateControlPoint();
p1.Translation = new Vec3F(1, 0, 0);
ControlPoints.Add(p1);
}
TransformationType = TransformationTypes.Translation;
DomNode.ChildInserted += DomNode_HierarchyChanged;
DomNode.ChildRemoved += DomNode_HierarchyChanged;
}
/// <summary>
/// Adds control point at the end of the internal list</summary>
/// <param name="cp">Control point</param>
public void AddControlPoint(IControlPoint cp)
{
m_pointList.Add(cp);
}
/// <summary>
/// Snaps control point along x axis to snapvalue</summary>
private void SnapToX(IControlPoint cpt, float snapValue)
{
ICurve curve = cpt.Parent;
int index = curve.ControlPoints.IndexOf(cpt);
if (index == -1)
throw new ArgumentException("cpt");
float s = CurveUtils.SnapTo(cpt.X, snapValue);
IControlPoint neighbor = null;
if (cpt.X > s) // snap left.
{
neighbor = (index != 0) ? curve.ControlPoints[index - 1] : null;
if (neighbor != null && Math.Abs(neighbor.X - s) <= CurveUtils.Epsilone)
{
cpt.X = neighbor.X + CurveUtils.Epsilone;
}
else
{
cpt.X = s;
}
}
else if (cpt.X < s)
{
neighbor = ((index + 1) < curve.ControlPoints.Count) ? curve.ControlPoints[index + 1] : null;
if (neighbor != null && Math.Abs(neighbor.X - s) <= CurveUtils.Epsilone)
{
cpt.X = neighbor.X - CurveUtils.Epsilone;
}
else
{
cpt.X = s;
}
}
}
/// <summary>
/// Snaps control point along y axis to snapValue</summary>
private void SnapToY(IControlPoint cpt, float snapValue)
{
float s = CurveUtils.SnapTo(cpt.Y, snapValue);
cpt.Y = s;
}
/// <summary>
/// Copies selected points to internal clipboard</summary>
public void Copy()
{
if (m_selection.Count > 0)
{
s_clipboard = new IControlPoint[m_selection.Count];
int i = 0;
foreach (IControlPoint cp in m_selection)
{
s_clipboard[i++] = cp.Clone();
}
}
}
/// <summary>
/// Snaps p1 to v2</summary>
private void SnapPoint(IControlPoint p1, Vec2F v2, float threshold)
{
Vec2F v1 = new Vec2F(p1.X, p1.Y);
Vec2F v3 = v1 - v2;
v3 = GraphToClientTangent(v3);
float dist = v3.Length;
if (dist > threshold)
return;
p1.Y = v2.Y;
float s = v2.X;
ICurve curve = p1.Parent;
int index = curve.ControlPoints.IndexOf(p1);
if (index == -1)
throw new ArgumentException("p1");
IControlPoint neighbor = null;
if (p1.X > s) // snap left.
{
neighbor = (index != 0) ? curve.ControlPoints[index - 1] : null;
if (neighbor != null && Math.Abs(neighbor.X - s) <= CurveUtils.Epsilone)
{
p1.X = neighbor.X + CurveUtils.Epsilone;
}
else
{
p1.X = s;
}
}
else if (p1.X < s)
{
neighbor = ((index + 1) < curve.ControlPoints.Count) ? curve.ControlPoints[index + 1] : null;
if (neighbor != null && Math.Abs(neighbor.X - s) <= CurveUtils.Epsilone)
{
p1.X = neighbor.X - CurveUtils.Epsilone;
}
else
{
p1.X = s;
}
}
}
/// <summary>
/// Cuts selected points</summary>
public void Cut()
{
if (m_selection.Count > 0)
{
s_clipboard = new IControlPoint[m_selection.Count];
m_transactionContext.DoTransaction(delegate
{
int i = 0;
foreach (IControlPoint cp in m_selection)
{
ICurve curve = cp.Parent;
curve.RemoveControlPoint(cp);
s_clipboard[i++] = cp;
}
foreach (ICurve curve in m_selectedCurves)
CurveUtils.ComputeTangent(curve);
}, "Cut".Localize());
ClearSelection();
UpdateCurveLimits();
Invalidate();
}
}
/// <summary>
/// Determines if given control point's x coordinate is in sorted order</summary>
/// <param name="cp">Control point</param>
/// <returns>True iff control point's x coordinate is in sorted order</returns>
public static bool IsSorted(IControlPoint cp)
{
bool valid = true;
ICurve curve = cp.Parent;
int index = curve.ControlPoints.IndexOf(cp);
if (index == -1)
throw new ArgumentException("cp not found in parent curve");
int lastIndex = curve.ControlPoints.Count - 1;
if (index < lastIndex)
{
IControlPoint nextcp = curve.ControlPoints[index + 1];
if (cp.X > nextcp.X)
{
valid = false;
}
}
if (valid && index > 0)
{
IControlPoint prevCp = curve.ControlPoints[index - 1];
if (cp.X < prevCp.X )
{
valid = false;
}
}
return valid;
}
/// <summary>
/// Inserts control point with the specified index into the internal list</summary>
/// <param name="index">Index</param>
/// <param name="cp">Control point</param>
public void InsertControlPoint(int index, IControlPoint cp)
{
m_pointList.Insert(index, cp);
}
/// <summary>
/// Removes given control point from the internal list</summary>
/// <param name="cp">Control point</param>
public void RemoveControlPoint(IControlPoint cp)
{
m_pointList.Remove(cp);
}
private void ComputeHermiteCoeff(IControlPoint p1, IControlPoint p2, float[] Coeff)
{
Vec2F t1 = new Vec2F(p1.TangentOut.X, p1.TangentOut.Y);
Vec2F t2 = new Vec2F(p2.TangentIn.X, p2.TangentIn.Y);
float m1 = 0.0f;
if (t1.X != 0.0f)
{
m1 = t1.Y / t1.X;
}
float m2 = 0.0f;
if (t2.X != 0.0f)
{
m2 = t2.Y / t2.X;
}
float dx = p2.X - p1.X;
float dy = p2.Y - p1.Y;
float length = 1.0f / (dx * dx);
float d1 = dx * m1;
float d2 = dx * m2;
Coeff[0] = (d1 + d2 - dy - dy) * length / dx;
Coeff[1] = (dy + dy + dy - d1 - d1 - d2) * length;
Coeff[2] = m1;
Coeff[3] = p1.Y;
}
/// <summary>
/// Draws single control point</summary>
/// <param name="prevTanType">Previous CurveTangentTypes</param>
/// <param name="cp">Control point</param>
/// <param name="g">Graphics object</param>
private void DrawControlPoint(CurveTangentTypes prevTanType, IControlPoint cp, Graphics g)
{
Vec2F p = m_canvas.GraphToClient(cp.X, cp.Y);
PointSelectionRegions region = cp.EditorData.SelectedRegion;
if (region != PointSelectionRegions.None)
{
if (prevTanType != CurveTangentTypes.Stepped && prevTanType != CurveTangentTypes.SteppedNext)
{
Vec2F tangIn = Vec2F.Normalize(m_canvas.GraphToClientTangent(cp.TangentIn));
tangIn.X = -tangIn.X;
tangIn.Y = -tangIn.Y;
DrawArrow(p, p + tangIn * m_tangentLength, g, m_tangentColor);
}
if (cp.TangentOutType != CurveTangentTypes.Stepped && cp.TangentOutType != CurveTangentTypes.SteppedNext)
{
Vec2F tangOut = Vec2F.Normalize(m_canvas.GraphToClientTangent(cp.TangentOut));
DrawArrow(p, p + tangOut * m_tangentLength, g, m_tangentColor);
}
}
RectangleF pointRect = new RectangleF();
float halfPointSize = m_pointSize / 2;
pointRect.X = p.X - halfPointSize;
pointRect.Y = p.Y - halfPointSize;
pointRect.Width = m_pointSize;
pointRect.Height = m_pointSize;
if (region == PointSelectionRegions.Point)
g.FillRectangle(m_pointHiBrush, pointRect);
else
g.FillRectangle(m_pointBrush, pointRect);
}
