// let the base class take care of positioning the first line // however after choosing the end of that line becomes point 2 and point 1 is then moved (and point 3 is automatic) public override VerbResult Choose(EditableView.ClickPosition position) { PointF pt = position.Snapped; if (pt.ApproxEqual(LastDefined)) { return(VerbResult.Rejected); } DiscardPath(); switch (m_DefinedVertices) { case 1: SetLength(4); Vertices[2] = pt; Vertices[1] = Geometry.MidPoint(Vertices[0], Vertices[2]); m_DefinedVertices = 2; Float(position); return(VerbResult.Continuing); case 2: Float(position); if (Geometry.PointApproxOnLine(Vertices[0], Vertices[2], Vertices[1])) { return(VerbResult.Rejected); } return(VerbResult.Completed); default: throw new InvalidOperationException(); } }
public override VerbResult Float(EditableView.ClickPosition position) { PointF pt = position.Snapped; if (!m_PositionFixed) { var sz = GetSize(); if (SingleClickPlacement) { // In this case we are placing the centre pt.X -= m_ImageSize.Width / NOMINALPIXELSPERMILLIMETRE * 0.5f; pt.Y -= m_ImageSize.Height / NOMINALPIXELSPERMILLIMETRE * 0.5f; //Debug.WriteLine(m_Bounds) } SetRectangle(new RectangleF(pt, sz)); } else { SizeF newSize = new SizeF(pt.X - Vertices[0].X, pt.Y - Vertices[0].Y); float imageRatio = (float)m_ImageSize.Width / m_ImageSize.Height; float adjustment = imageRatio / (newSize.Width / newSize.Height); // correction needed to the aspect ratio // we add on half each on width and height newSize.Width *= (float)Math.Sqrt(adjustment); newSize.Height /= (float)Math.Sqrt(adjustment); m_SizeAcceptable = DimensionAcceptable(newSize.Width, m_ImageSize.Width) && DimensionAcceptable(newSize.Height, m_ImageSize.Height); if (m_SizeAcceptable) { SetRectangle(new RectangleF(Vertices[0], newSize)); } } return(VerbResult.Continuing); }
public override VerbResult Float(EditableView.ClickPosition position) { if (m_DefinedVertices < 2) { return(base.Float(position)); } // actually floating point 1 in this case and 0 and 2 are fixed PointF pt = position.Snapped; if (pt.Equals(Vertices[1])) { return(VerbResult.Unchanged); } // find point on base line closest to floating point. PointF closest = Geometry.ClosestPointOnLine(Vertices[0], Vertices[2], pt); // vector from that to float gives us the vector for the second axis (effectively it's ony the length that matters) PointF centre = Geometry.MidPoint(Vertices[0], Vertices[2]); SizeF halfSecondAxis = closest.VectorTo(pt); Vertices[1] = centre + halfSecondAxis; Vertices[3] = centre - halfSecondAxis; m_Acceptable = !Geometry.PointApproxOnLine(Vertices[0], Vertices[2], Vertices[1]); m_Bounds = CalculateBounds(); DiscardPath(); return(VerbResult.Continuing); }
public override VerbResult Float(EditableView.ClickPosition position) { if (m_DefinedVertices < 2) { return(base.Float(position)); } // If pt.Equals(m_aVertices(2)) Then Return RectangleF.Empty ' polygon is unchanged - no need to do the further calculations // CANT DO THAT DUE TO ChangeSizeVerb Vertices[2] = position.Snapped; m_Bounds = RectangleF.Empty; // invalidate the bounds int direction = base.TurnDirection(); if (direction == 0) { m_Acceptable = false; for (int index = 2; index <= m_Sides - 1; index++) { Vertices[index] = Vertices[1]; } } else { PlacePoints(direction); m_Acceptable = true; } return(VerbResult.Continuing); }
public override VerbResult Float(EditableView.ClickPosition pt) { if (m_DefinedVertices >= Vertices.Count) { Debug.Fail("Curve: Float no points are undetermined"); return(VerbResult.Unchanged); } if (m_DefinedVertices == 0) { return(VerbResult.Continuing); // don't think this actually happen, but just in case } if (Vertices[m_DefinedVertices].ApproxEqual(pt.Snapped)) { return(VerbResult.Rejected); } if (m_DefinedVertices >= 2 && !m_Closed && pt.Exact.ApproxEqual(Vertices[0])) { // auto-close - complete will change to closed Vertices[m_DefinedVertices] = Vertices[0]; } else { Vertices[m_DefinedVertices] = pt.Snapped; } SetControlPoints(m_DefinedVertices - 1); if (m_Closed) { SetControlPoints(0, 0); } DiscardDerived(); return(VerbResult.Continuing); }
public override VerbResult Choose(EditableView.ClickPosition position) { if (!m_BaseLineFixed) { if (Float(position) == VerbResult.Rejected) { return(VerbResult.Rejected); } m_BaseLineFixed = true; if (m_Label == null) { m_Label = ""; } FormatText(0); // will format the EmptyText prompt CaretGain(); m_Bounds = CalculateBounds(); return(VerbResult.Continuing); } else // will complete the shape, fixing the text { if (string.IsNullOrEmpty(m_Label)) { return(VerbResult.Rejected); } CaretLose(); return(VerbResult.Completed); } }
public override VerbResult OtherVerb(EditableView.ClickPosition position, SAW.Functions.Codes code) { switch (code) { case SAW.Functions.Codes.Increment: case SAW.Functions.Codes.Decrement: int delta = code == SAW.Functions.Codes.Increment ? 1 : -1; float step = position.ScalarSnapStep(0); if (step <= 0) { step = delta * Globals.Root.CurrentConfig.ReadSingle(Config.Radius_Step, 1); } else { step *= delta; } SizeF vector = Vertices[0].VectorTo(Vertices[1]); float length = vector.Length(); if (length + step < 5 || length < Geometry.NEGLIGIBLESMALL) { return(VerbResult.Rejected); } Vertices[1] = Vertices[0] + vector.ChangeLength(length + step); m_Bounds = RectangleF.Empty; return(VerbResult.Continuing); default: return(VerbResult.Rejected); } }
public override VerbResult Float(EditableView.ClickPosition position) { // let the base class take care of positioning the first line if (m_DefinedVertices < 2) { return(base.Float(position)); } // need to calculate the coordinates of the fourth point. We can add the 1>2 vector onto point 0 Debug.Assert(Vertices.Count == 4); PointF newPoint = Geometry.PerpendicularPoint(Vertices[0], Vertices[1], position.Snapped); if (newPoint.Equals(Vertices[2])) { return(VerbResult.Unchanged); } if (newPoint.ApproxEqual(Vertices[1])) { return(VerbResult.Rejected); } Vertices[2] = newPoint; SizeF vector = Vertices[1].VectorTo(Vertices[2]); Vertices[3] = PointF.Add(Vertices[0], vector); m_Bounds = CalculateBounds(); m_Acceptable = !VerticesFormLine(0); DiscardPath(); return(VerbResult.Continuing); }
public override VerbResult Start(EditableView.ClickPosition position) { Element = new Item { Parent = this }; SetUniqueID(); return(Element.Start(position)); }
public override VerbResult Float(EditableView.ClickPosition position) { // I think that the base class Float is sufficient, except that it does not set m_bolAcceptable var eResult = base.Float(position); m_Acceptable = m_DefinedVertices >= 2 && !VerticesFormLine(0); return(eResult); }
public override VerbResult Cancel(EditableView.ClickPosition position) { if (!string.IsNullOrEmpty(m_Label)) { return(Complete(position)); } return(VerbResult.Destroyed); }
public override VerbResult Complete(EditableView.ClickPosition position) { if (!m_BaseLineFixed) { return(Choose(position)); } return(CompleteRetrospective()); }
public override VerbResult Float(EditableView.ClickPosition pt) { Vertices[Vertices.Count - 1] = pt.Snapped; UpdateLink(1, pt); PositionLine(); m_Acceptable = !EndsEqual && !Vertices[0].ApproxEqual(Vertices[Vertices.Count - 1]); m_Bounds = RectangleF.Empty; return(VerbResult.Continuing); }
public override VerbResult Start(EditableView.ClickPosition position) { m_Start = position.Snapped; base.Start(position); Vertices.Add(m_Start); Vertices.Add(m_Start); m_DefinedVertices = 2; // sort of! return(VerbResult.Continuing); }
public override VerbResult Cancel(EditableView.ClickPosition position) { if (Vertices.Count != 2 || m_DefinedVertices != 1) { return(VerbResult.Unexpected); } // this can only happen when we have one vertex specified - it will always cancel the entire shape return(VerbResult.Destroyed); }
public override VerbResult Cancel(EditableView.ClickPosition position) { if (!m_PositionFixed) { return(VerbResult.Destroyed); } m_PositionFixed = false; SetDefaultSize(); return(VerbResult.Continuing); }
public override VerbResult Choose(EditableView.ClickPosition position) { if (position.Snapped.ApproxEqual(LastDefined)) { return(VerbResult.Rejected); } Float(position); FixVertex(); return(VerbResult.Continuing); }
public override VerbResult Choose(EditableView.ClickPosition position) { Float(position); if (m_Bounds.Width < 1 || m_Bounds.Height < 1) { return(VerbResult.Rejected); } m_DefinedVertices = 4; return(VerbResult.Completed); }
private const float ADDMMPERDEGREE = 0.05f; // ie 90deg = 4.5 extra (90° is the maximum considered) public override VerbResult Start(EditableView.ClickPosition position) { m_Targets = new List <PointF>(); m_Targets.Add(position.Snapped); Debug.Assert(LineStyle != null && FillStyle != null); LineStyle.SetDefaults(); FillStyle.Colour = Color.Empty; FillStyle.Pattern = FillStyleC.Patterns.Solid; g_dtLastTargetAdded = DateTime.Now; return(VerbResult.Continuing); }
public override VerbResult Start(EditableView.ClickPosition position) { base.AddLink(null, 0); base.AddLink(null, 0); VerbResult result = base.Start(position); UpdateLink(0, position); // but we deliberately leave the other one floating; otherwise it would just point to the same socket m_Acceptable = false; m_DefinedVertices = 2; // not used by this class and confuses base class return(result); }
public override VerbResult Complete(EditableView.ClickPosition position) { if (Vertices.Count != 2 || m_DefinedVertices != 1) { return(VerbResult.Unexpected); } Vertices[1] = position.Snapped; m_DefinedVertices = 2; m_Bounds = RectangleF.Empty; return(VerbResult.Completed); }
public override VerbResult Start(EditableView.ClickPosition position) { m_Start = position.Snapped; m_End = m_Start; if (MultiMode) { m_OriginalSelection = new List <Shape>(); m_OriginalSelection.AddRange(position.Page.SelectedShapes); } return(VerbResult.Continuing); }
public override VerbResult Cancel(EditableView.ClickPosition position) { // unless overridden in a subclass this will remove one DEFINED vertex // and trim the vertex array to contain just the defined ones plus one floating // the vertex array may currently contain any number of other postulated ones if (m_DefinedVertices <= 1) { return(VerbResult.Destroyed); } DiscardVertex(); return(VerbResult.Continuing); }
public override VerbResult Start(EditableView.ClickPosition position) { PointF pt = position.Snapped; Vertices[0] = pt; Vertices[1] = pt; m_BaseLineFixed = false; Debug.Assert(TextStyle != null); TextStyle.SetDefaults(); TextStyle.Alignment = StringAlignment.Near; return(VerbResult.Continuing); }
public override VerbResult Choose(EditableView.ClickPosition position) { PointF point = position.Snapped; if (point.ApproxEqual(LastDefined)) { return(VerbResult.Rejected); } Vertices[Vertices.Count - 1] = point; FixVertex(); return(VerbResult.Continuing); }
public override AllowedActions Allows => AllowedActions.None; // not actually used? #endregion #region Verbs public override VerbResult Cancel(EditableView.ClickPosition position) { if (!MultiMode) { position.Page.DeselectAll(); } else { position.Page.SelectOnly(m_OriginalSelection); } return(VerbResult.Destroyed); }
public override VerbResult OtherVerb(EditableView.ClickPosition position, Functions.Codes code) { switch (code) { case Functions.Codes.Increment: case Functions.Codes.Decrement: int delta = code == Functions.Codes.Increment ? 1 : -1; return(ChangeSides(delta)); default: return(VerbResult.Rejected); } }
public override VerbResult Cancel(EditableView.ClickPosition position) { if (!m_BaseLineFixed) { return(VerbResult.Destroyed); } if (!string.IsNullOrEmpty(m_Label)) { return(Complete(position)); } m_BaseLineFixed = false; CaretLose(); return(VerbResult.Continuing); }
public override VerbResult Cancel(EditableView.ClickPosition position) { if (m_DefinedVertices <= 1) { return(VerbResult.Destroyed); } m_DefinedVertices -= 1; SetLength(m_DefinedVertices + 1); if (m_Closed) // the final, closing vertex has been renumbered. This will have been deleted off the end of the list { Vertices[Vertices.Count - 1] = Vertices[0]; } return(VerbResult.Continuing); }
public override VerbResult Complete(EditableView.ClickPosition position) { if (Vertices.Count != 2 || m_DefinedVertices != 1) { return(VerbResult.Unexpected); } Float(position); m_DefinedVertices = 2; if (Vertices[0].ApproxEqual(Vertices[1])) { return(VerbResult.Destroyed); } return(VerbResult.Completed); }