public DataModel() { m_toolTypes.Clear(); m_toolTypes[DrawTools.Line.ObjectType] = typeof(DrawTools.Line); m_toolTypes[DrawTools.Circle.ObjectType] = typeof(DrawTools.Circle); m_toolTypes[DrawTools.Arc.ObjectType] = typeof(DrawTools.Arc); m_toolTypes[DrawTools.Arc3Point.ObjectType] = typeof(DrawTools.Arc3Point); DefaultLayer(); m_centerPoint = new UnitPoint(0,0); }
public static bool IsPointInOval(UnitPoint center, float halfWidth, float halfHeight, UnitPoint testPoint) { OvalFun fun = (pCenter, a, b, pTest) => { float xx = (float)(pCenter.X - pTest.X); float yy = (float)(pCenter.Y - pTest.Y); return(xx * xx / (a * a) + yy * yy / (b * b)); }; double dist = Math.Abs(fun(center, halfWidth, halfHeight, testPoint)); return(dist < 1.0f); }
protected override void OnResize(EventArgs e) { base.OnResize(e); if (m_lastCenterPoint != UnitPoint.Empty && Width != 0) SetCenterScreen(ToScreen(m_lastCenterPoint), false); m_lastCenterPoint = CenterPointUnit(); m_staticImage = null; DoInvalidate(true); }
public void DrawLine(ICanvas canvas, Pen pen, UnitPoint p1, UnitPoint p2) { PointF tmpp1 = ToScreen(p1); PointF tmpp2 = ToScreen(p2); canvas.Graphics.DrawLine(pen, tmpp1, tmpp2); }
protected override void OnMouseMove(MouseEventArgs e) { base.OnMouseMove(e); if (m_selection != null) { Graphics dc = Graphics.FromHwnd(Handle); m_selection.SetMousePoint(dc, new PointF(e.X, e.Y)); dc.Dispose(); return; } if (m_commandType == eCommandType.pan && e.Button == MouseButtons.Left) { m_dragOffset.X = -(m_mousedownPoint.X - e.X); m_dragOffset.Y = -(m_mousedownPoint.Y - e.Y); m_lastCenterPoint = CenterPointUnit(); DoInvalidate(true); } UnitPoint mousepoint; UnitPoint unitpoint = ToUnit(new PointF(e.X, e.Y)); if (m_commandType == eCommandType.draw || m_commandType == eCommandType.move || m_nodeMoveHelper.IsEmpty == false) { Rectangle invalidaterect = Rectangle.Empty; ISnapPoint newsnap = null; mousepoint = GetMousePoint(); if (RunningSnapsEnabled) newsnap = m_model.SnapPoint(m_canvaswrapper, mousepoint, m_runningSnapTypes, null); if (newsnap == null) newsnap = m_model.GridLayer.SnapPoint(m_canvaswrapper, mousepoint, null); if ((m_snappoint != null) && ((newsnap == null) || (newsnap.SnapPoint != m_snappoint.SnapPoint) || m_snappoint.GetType() != newsnap.GetType())) { invalidaterect = ScreenUtils.ConvertRect(ScreenUtils.ToScreenNormalized(m_canvaswrapper, m_snappoint.BoundingRect)); invalidaterect.Inflate(2, 2); RepaintStatic(invalidaterect); // remove old snappoint m_snappoint = newsnap; } if (m_commandType == eCommandType.move) Invalidate(invalidaterect); if (m_snappoint == null) m_snappoint = newsnap; } m_owner.SetPositionInfo(unitpoint); m_owner.SetSnapInfo(m_snappoint); //UnitPoint mousepoint; if (m_snappoint != null) mousepoint = m_snappoint.SnapPoint; else mousepoint = GetMousePoint(); if (m_newObject != null) { Rectangle invalidaterect = ScreenUtils.ConvertRect(ScreenUtils.ToScreenNormalized(m_canvaswrapper, m_newObject.GetBoundingRect(m_canvaswrapper))); invalidaterect.Inflate(2, 2); RepaintStatic(invalidaterect); m_newObject.OnMouseMove(m_canvaswrapper, mousepoint); RepaintObject(m_newObject); } if (m_snappoint != null) RepaintSnappoint(m_snappoint); if (m_moveHelper.HandleMouseMoveForMove(mousepoint)) Refresh(); //Invalidate(); RectangleF rNoderect = m_nodeMoveHelper.HandleMouseMoveForNode(mousepoint); if (rNoderect != RectangleF.Empty) { Rectangle invalidaterect = ScreenUtils.ConvertRect(ScreenUtils.ToScreenNormalized(m_canvaswrapper, rNoderect)); RepaintStatic(invalidaterect); CanvasWrapper dc = new CanvasWrapper(this, Graphics.FromHwnd(Handle), ClientRectangle); dc.Graphics.Clip = new Region(ClientRectangle); //m_nodeMoveHelper.DrawOriginalObjects(dc, rNoderect); m_nodeMoveHelper.DrawObjects(dc, rNoderect); if (m_snappoint != null) RepaintSnappoint(m_snappoint); dc.Graphics.Dispose(); dc.Dispose(); } }
public GridSnapPoint(ICanvas canvas, UnitPoint snappoint) : base(canvas, null, snappoint) { }
PointF Translate(UnitPoint point) { return point.Point; }
public static UnitPoint LinesIntersectPoint(UnitPoint lp1, UnitPoint lp2, UnitPoint lp3, UnitPoint lp4) { double x = 0; double y = 0; if (LinesIntersect(lp1, lp2, lp3, lp4, ref x, ref y, true, false, false)) { return(new UnitPoint(x, y)); } return(UnitPoint.Empty); }
public static UnitPoint FindApparentIntersectPoint(UnitPoint lp1, UnitPoint lp2, UnitPoint lp3, UnitPoint lp4, bool extendA, bool extendB) { double x = 0; double y = 0; if (LinesIntersect(lp1, lp2, lp3, lp4, ref x, ref y, true, extendA, extendB)) { return(new UnitPoint(x, y)); } return(UnitPoint.Empty); }
private static bool LinesIntersect(UnitPoint lp1, UnitPoint lp2, UnitPoint lp3, UnitPoint lp4, ref double x, ref double y, bool returnpoint, bool extendA, bool extendB) { // http://local.wasp.uwa.edu.au/~pbourke/geometry/lineline2d/ // line a is given by P1 and P2, point of intersect for line a (Pa) and b (Pb) // Pa = P1 + ua ( P2 - P1 ) // Pb = P3 + ub ( P4 - P3 ) // ua(x) = ub(x) and ua(y) = ub (y) // x1 + ua (x2 - x1) = x3 + ub (x4 - x3) // y1 + ua (y2 - y1) = y3 + ub (y4 - y3) // ua = ((x4-x3)(y1-y3) - (y4-y3)(x1-x3)) / ((x4-x3)(x2-x1) - (x4-x3)(y2-y1)) // ub = ((x2-x1)(y1-y3) - (y2-y1)(x1-x3)) / ((y4-y3)(x2-x1) - (x4-x3)(y2-y1)) // intersect point x = x1 + ua (x2 - x1) // intersect point y = y1 + ua (y2 - y1) double x1 = lp1.X; double x2 = lp2.X; double x3 = lp3.X; double x4 = lp4.X; double y1 = lp1.Y; double y2 = lp2.Y; double y3 = lp3.Y; double y4 = lp4.Y; double denominator = ((y4 - y3) * (x2 - x1) - (x4 - x3) * (y2 - y1)); if (denominator == 0) // lines are parallel { return(false); } double numerator_ua = ((x4 - x3) * (y1 - y3) - (y4 - y3) * (x1 - x3)); double numerator_ub = ((x2 - x1) * (y1 - y3) - (y2 - y1) * (x1 - x3)); double ua = numerator_ua / denominator; double ub = numerator_ub / denominator; // if a line is not extended then ua (or ub) must be between 0 and 1 if (extendA == false) { if (ua < 0 || ua > 1) { return(false); } } if (extendB == false) { if (ub < 0 || ub > 1) { return(false); } } if (extendA || extendB) // no need to chck range of ua and ub if check is one on lines { x = x1 + ua * (x2 - x1); y = y1 + ua * (y2 - y1); return(true); } if (ua >= 0 && ua <= 1 && ub >= 0 && ub <= 1) { if (returnpoint) { x = x1 + ua * (x2 - x1); y = y1 + ua * (y2 - y1); } return(true); } return(false); }
public static bool LinesIntersect(UnitPoint lp1, UnitPoint lp2, UnitPoint lp3, UnitPoint lp4) { double x = 0; double y = 0; return(LinesIntersect(lp1, lp2, lp3, lp4, ref x, ref y, false, false, false)); }
public static bool IsPointInLine(UnitPoint linepoint1, UnitPoint linepoint2, UnitPoint testpoint, float halflinewidth) { UnitPoint p1 = linepoint1; UnitPoint p2 = linepoint2; UnitPoint p3 = testpoint; // check bounding rect, this is faster than creating a new rectangle and call r.Contains double lineLeftPoint = Math.Min(p1.X, p2.X) - halflinewidth; double lineRightPoint = Math.Max(p1.X, p2.X) + halflinewidth; if (testpoint.X < lineLeftPoint || testpoint.X > lineRightPoint) { return(false); } double lineBottomPoint = Math.Min(p1.Y, p2.Y) - halflinewidth; double lineTopPoint = Math.Max(p1.Y, p2.Y) + halflinewidth; if (testpoint.Y < lineBottomPoint || testpoint.Y > lineTopPoint) { return(false); } // then check if it hits the endpoint if (CircleHitPoint(p1, halflinewidth, p3)) { return(true); } if (CircleHitPoint(p2, halflinewidth, p3)) { return(true); } if (p1.Y == p2.Y) // line is horizontal { double min = Math.Min(p1.X, p2.X) - halflinewidth; double max = Math.Max(p1.X, p2.X) + halflinewidth; if (p3.X >= min && p3.X <= max) { return(true); } return(false); } if (p1.X == p2.X) // line is vertical { double min = Math.Min(p1.Y, p2.Y) - halflinewidth; double max = Math.Max(p1.Y, p2.Y) + halflinewidth; if (p3.Y >= min && p3.Y <= max) { return(true); } return(false); } // using COS law // a^2 = b^2 + c^2 - 2bc COS A // A = ACOS ((a^2 - b^2 - c^2) / (-2bc)) double xdiff = Math.Abs(p2.X - p3.X); double ydiff = Math.Abs(p2.Y - p3.Y); double aSquare = Math.Pow(xdiff, 2) + Math.Pow(ydiff, 2); double a = Math.Sqrt(aSquare); xdiff = Math.Abs(p1.X - p2.X); ydiff = Math.Abs(p1.Y - p2.Y); double bSquare = Math.Pow(xdiff, 2) + Math.Pow(ydiff, 2); double b = Math.Sqrt(bSquare); xdiff = Math.Abs(p1.X - p3.X); ydiff = Math.Abs(p1.Y - p3.Y); double cSquare = Math.Pow(xdiff, 2) + Math.Pow(ydiff, 2); double c = Math.Sqrt(cSquare); double A = Math.Acos(((aSquare - bSquare - cSquare) / (-2 * b * c))); // once we have A we can find the height (distance from the line) // SIN(A) = (h / c) // h = SIN(A) * c; double h = Math.Sin(A) * c; // now if height is smaller than half linewidth, the hitpoint is within the line return(h <= halflinewidth); }
static UnitPoint() { Empty = new UnitPoint(); Empty.m_x = double.NaN; Empty.m_y = double.NaN; }
public static bool CircleIntersectWithLine(UnitPoint center, float radius, UnitPoint lp1, UnitPoint lp2) { // check if both points are inside the circle, in that case the line does not intersect the circle if ((Distance(center, lp1) < radius && Distance(center, lp2) < radius)) { return(false); } // find the nearest point from the line to center, if that point is smaller than radius, // then the line does intersect the circle UnitPoint np = NearestPointOnLine(lp1, lp2, center); double dist = Distance(center, np); if (dist <= radius) { return(true); } return(false); }
ISnapPoint ICanvasLayer.SnapPoint(ICanvas canvas, UnitPoint point, List<IDrawObject> otherobj) { throw new Exception("The method or operation is not implemented."); }
public static UnitPoint OrthoPointD(UnitPoint lp1, UnitPoint lp2, double roundToAngleR) { return(OrthoPointR(lp1, lp2, DegressToRadians(roundToAngleR))); }
public SnapPointBase(ICanvas canvas, IDrawObject owner, UnitPoint snappoint) { m_owner = owner; m_snappoint = snappoint; float size = (float)canvas.ToUnit(14); m_boundingRect.X = (float)(snappoint.X - size / 2); m_boundingRect.Y = (float)(snappoint.Y - size / 2); m_boundingRect.Width = size; m_boundingRect.Height = size; }
public static UnitPoint OrthoPointR(UnitPoint lp1, UnitPoint lp2, double roundToAngleR) { return(NearestPointOnLine(lp1, lp2, lp2, roundToAngleR)); }
public EditCommandMove(UnitPoint offset, IEnumerable<IDrawObject> objects) { m_objects = new List<IDrawObject>(objects); m_offset = offset; }
public static UnitPoint NearestPointOnLine(UnitPoint lp1, UnitPoint lp2, UnitPoint tp) { return(NearestPointOnLine(lp1, lp2, tp, false)); }
public UnitPoint CenterPointUnit() { UnitPoint p1 = ScreenTopLeftToUnitPoint(); UnitPoint p2 = ScreenBottomRightToUnitPoint(); UnitPoint center = new UnitPoint(); center.X = (p1.X + p2.X) / 2; center.Y = (p1.Y + p2.Y) / 2; return center; }
public static double LineSlope(UnitPoint p1, UnitPoint p2) { return((p2.Y - p1.Y) / (p2.X - p1.X)); }
public PointF ToScreen(UnitPoint point) { PointF transformedPoint = Translate(point); transformedPoint.Y = ScreenHeight() - transformedPoint.Y; transformedPoint.Y *= m_screenResolution * m_model.Zoom; transformedPoint.X *= m_screenResolution * m_model.Zoom; transformedPoint.X += m_panOffset.X + m_dragOffset.X; transformedPoint.Y += m_panOffset.Y + m_dragOffset.Y; return transformedPoint; }
public MidpointSnapPoint(ICanvas canvas, IDrawObject owner, UnitPoint snappoint, int id = 0) : base(canvas, owner, snappoint) { m_id = id; }
protected override void OnMouseWheel(MouseEventArgs e) { UnitPoint p = GetMousePoint(); float wheeldeltatick = 120; float zoomdelta = (1.25f * (Math.Abs(e.Delta) / wheeldeltatick)); if (e.Delta < 0) m_model.Zoom = m_model.Zoom / zoomdelta; else m_model.Zoom = m_model.Zoom * zoomdelta; SetCenterScreen(ToScreen(p), true); m_lastCenterPoint = p; DoInvalidate(true); base.OnMouseWheel(e); }
public DivisionSnapPoint(ICanvas canvas, IDrawObject owner, UnitPoint snappoint) : base(canvas, owner, snappoint) { }
public IDrawObject CreateObject(string type, UnitPoint point, ISnapPoint snappoint) { DrawingLayer layer = ActiveLayer as DrawingLayer; if (layer.Enabled == false) return null; DrawTools.DrawObjectBase newobj = CreateObject(type); if (newobj != null) { newobj.Layer = layer; newobj.InitializeFromModel(point, layer, snappoint); } return newobj as IDrawObject; }
public PerpendicularSnapPoint(ICanvas canvas, IDrawObject owner, UnitPoint snappoint) : base(canvas, owner, snappoint) { }
public void MoveObjects(UnitPoint offset, IEnumerable<IDrawObject> objects) { if (m_undoBuffer.CanCapture) m_undoBuffer.AddCommand(new EditCommandMove(offset, objects)); foreach (IDrawObject obj in objects) obj.Move(offset); }
public TangentSnapPoint(ICanvas canvas, IDrawObject owner, UnitPoint snappoint) : base(canvas, owner, snappoint) { }
public static RectangleF GetRect(UnitPoint p1, UnitPoint p2, double width) { double x = Math.Min(p1.X, p2.X); double y = Math.Min(p1.Y, p2.Y); double w = Math.Abs(p1.X - p2.X); double h = Math.Abs(p1.Y - p2.Y); RectangleF rect = ScreenUtils.GetRect(x, y, w, h); rect.Inflate((float)width, (float)width); return rect; }
protected override void OnMouseDown(MouseEventArgs e) { m_mousedownPoint = new PointF(e.X, e.Y); // used when panning m_dragOffset = new PointF(0, 0); UnitPoint mousepoint = ToUnit(m_mousedownPoint); if (m_snappoint != null) { mousepoint = m_snappoint.SnapPoint; } if (m_commandType == eCommandType.editNode) { bool handled = false; if (m_nodeMoveHelper.HandleMouseDown(mousepoint, ref handled)) { FinishNodeEdit(); base.OnMouseDown(e); return; } } if (m_commandType == eCommandType.select) { bool handled = false; if (m_nodeMoveHelper.HandleMouseDown(mousepoint, ref handled)) { m_commandType = eCommandType.editNode; m_snappoint = null; base.OnMouseDown(e); return; } m_selection = new SelectionRectangle(m_mousedownPoint); } if (m_commandType == eCommandType.move) { m_moveHelper.HandleMouseDownForMove(mousepoint, m_snappoint); } if (m_commandType == eCommandType.draw) { HandleMouseDownWhenDrawing(mousepoint, null); DoInvalidate(true); } if (m_commandType == eCommandType.edit) { if (m_editTool == null) { m_editTool = m_model.GetEditTool(m_editToolId); } if (m_editTool != null) { if (m_editTool.SupportSelection) { m_selection = new SelectionRectangle(m_mousedownPoint); } eDrawObjectMouseDown mouseresult = m_editTool.OnMouseDown(m_canvaswrapper, mousepoint, m_snappoint); /* * if (mouseresult == eDrawObjectMouseDown.Continue) * { * if (m_editTool.SupportSelection) * m_selection = new SelectionRectangle(m_mousedownPoint); * } * */ if (mouseresult == eDrawObjectMouseDown.Done) { m_editTool.Finished(); m_editTool = m_model.GetEditTool(m_editToolId); // continue with new tool //m_editTool = null; if (m_editTool.SupportSelection) { m_selection = new SelectionRectangle(m_mousedownPoint); } } } DoInvalidate(true); UpdateCursor(); } base.OnMouseDown(e); }
PointF Translate(UnitPoint point) { return(point.Point); }
public MidpointSnapPoint(ICanvas canvas, IDrawObject owner, UnitPoint snappoint) : base(canvas, owner, snappoint) { }
public void DrawLine(ICanvas canvas, Pen pen, UnitPoint p1, UnitPoint p2) { m_canvas.DrawLine(canvas, pen, p1, p2); }
public override bool DoUndo(IModel data) { foreach (IDrawObject obj in m_objects) { UnitPoint offset = new UnitPoint(-m_offset.X, -m_offset.Y); obj.Move(offset); } return true; }
public void DrawArc(ICanvas canvas, Pen pen, UnitPoint center, float radius, float beginangle, float angle) { m_canvas.DrawArc(canvas, pen, center, radius, beginangle, angle); }
public PointF ToScreen(UnitPoint unitpoint) { return m_canvas.ToScreen(unitpoint); }
/// <summary> /// 点的快照信息?(抛出异常) /// </summary> /// <param name="canvas"></param> /// <param name="point"></param> /// <param name="otherobj"></param> /// <returns></returns> ISnapPoint ICanvasLayer.SnapPoint(ICanvas canvas, UnitPoint point, List <IDrawObject> otherobj) { throw new Exception("The method or operation is not implemented."); }
public void DrawArc(ICanvas canvas, Pen pen, UnitPoint center, float radius, float startAngle, float sweepAngle) { PointF p1 = ToScreen(center); radius = (float)Math.Round(ToScreen(radius)); RectangleF r = new RectangleF(p1, new SizeF()); r.Inflate(radius, radius); if (radius > 0 && radius < 1e8f ) canvas.Graphics.DrawArc(pen, r, -startAngle, -sweepAngle); }
public void FillRectangle(ICanvas canvas, Brush brush, UnitPoint ptUpperLeft, float width, float height) { PointF ptScreen = ToScreen(ptUpperLeft); canvas.Graphics.FillRectangle(brush, ptScreen.X, ptScreen.Y, ToScreen(width), ToScreen(height)); }
public void SetCenter(UnitPoint unitPoint) { PointF point = ToScreen(unitPoint); m_lastCenterPoint = unitPoint; SetCenterScreen(point, false); }
public void DrawEllipse(ICanvas canvas, Pen pen, UnitPoint ptTopLeft, float width, float height) { m_canvas.DrawEllipse(canvas, pen, ptTopLeft, width, height); }
protected virtual void HandleMouseDownWhenDrawing(UnitPoint mouseunitpoint, ISnapPoint snappoint) { if (m_commandType == eCommandType.draw) { if (m_newObject == null) { m_newObject = m_model.CreateObject(m_drawObjectId, mouseunitpoint, snappoint); if (m_newObject.GetType().ToString().IndexOf("Module")>0) { eDrawObjectMouseDown result = m_newObject.OnMouseDown(m_canvaswrapper, mouseunitpoint, snappoint); switch (result) { case eDrawObjectMouseDown.Done: m_model.AddObject(m_model.ActiveLayer, m_newObject); m_newObject = null; DoInvalidate(true); break; case eDrawObjectMouseDown.DoneRepeat: m_model.AddObject(m_model.ActiveLayer, m_newObject); m_newObject = m_model.CreateObject(m_newObject.Id, m_newObject.RepeatStartingPoint, null); DoInvalidate(true); break; case eDrawObjectMouseDown.Continue: break; } } else DoInvalidate(false, m_newObject.GetBoundingRect(m_canvaswrapper)); } else { if (m_newObject != null) { eDrawObjectMouseDown result = m_newObject.OnMouseDown(m_canvaswrapper, mouseunitpoint, snappoint); switch (result) { case eDrawObjectMouseDown.Done: m_model.AddObject(m_model.ActiveLayer, m_newObject); m_newObject = null; DoInvalidate(true); break; case eDrawObjectMouseDown.DoneRepeat: m_model.AddObject(m_model.ActiveLayer, m_newObject); m_newObject = m_model.CreateObject(m_newObject.Id, m_newObject.RepeatStartingPoint, null); DoInvalidate(true); break; case eDrawObjectMouseDown.Continue: break; } } } } }
public void FillEllipse(ICanvas canvas, Brush brush, UnitPoint ptTopLeft, float width, float height) { m_canvas.FillEllipse(canvas, brush, ptTopLeft, width, height); }
public PointF ToScreen(UnitPoint unitpoint) { return(m_canvas.ToScreen(unitpoint)); }
protected override void OnMouseDown(MouseEventArgs e) { if (m_rectBaseTextBox != null && m_rectBaseTextBox.Tag != null) { ((DrawTools.RectBase)m_rectBaseTextBox.Tag).Text = m_rectBaseTextBox.Text; ((DrawTools.RectBase)m_rectBaseTextBox.Tag).Selected = false; Controls.Remove(m_rectBaseTextBox); m_model.ClearSelectedObjects(); m_rectBaseTextBox = null; DoInvalidate(true); return; } if (e.Button == MouseButtons.Middle) { CommandEscape(); CommandPan(); } if (e.Button == MouseButtons.Right) { CommandEscape(); } m_mousedownPoint = new PointF(e.X, e.Y); // used when panning m_dragOffset = new PointF(0, 0); UnitPoint mousepoint = ToUnit(m_mousedownPoint); if (m_snappoint != null) { mousepoint = m_snappoint.SnapPoint; //snap point: rect point } if (m_commandType == eCommandType.editNode) { //modify a obj's node, e.g: move node bool handled = false; if (m_nodeMoveHelper.HandleMouseDown(mousepoint, ref handled, m_snappoint)) { FinishNodeEdit(); base.OnMouseDown(e); return; } } if (m_commandType == eCommandType.select) { //select an exsiting obj bool handled = false; if (m_nodeMoveHelper.HandleMouseDown(mousepoint, ref handled, m_snappoint)) { m_commandType = eCommandType.editNode; m_snappoint = null; base.OnMouseDown(e); return; } m_selection = new SelectionRectangle(m_mousedownPoint); } if (m_commandType == eCommandType.move) { m_moveHelper.HandleMouseDownForMove(mousepoint, m_snappoint); } if (m_commandType == eCommandType.draw) { //make a new obj and add it to model HandleMouseDownWhenDrawing(mousepoint, m_snappoint); DoInvalidate(true); } if (m_commandType == eCommandType.edit) { if (m_editTool == null) { m_editTool = m_model.GetEditTool(m_editToolId); } if (m_editTool != null) { if (m_editTool.SupportSelection) { m_selection = new SelectionRectangle(m_mousedownPoint); } eDrawObjectMouseDown mouseresult = m_editTool.OnMouseDown(m_canvaswrapper, mousepoint, m_snappoint); /* * if (mouseresult == eDrawObjectMouseDown.Continue) * { * if (m_editTool.SupportSelection) * m_selection = new SelectionRectangle(m_mousedownPoint); * } * */ if (mouseresult == eDrawObjectMouseDown.Done) { m_editTool.Finished(); m_editTool = m_model.GetEditTool(m_editToolId); // continue with new tool //m_editTool = null; if (m_editTool.SupportSelection) { m_selection = new SelectionRectangle(m_mousedownPoint); } } } DoInvalidate(true); UpdateCursor(); } base.OnMouseDown(e); }
public void CopyObjects(UnitPoint offset, IEnumerable<IDrawObject> objects) { ClearSelectedObjects(); List<IDrawObject> newobjects = new List<IDrawObject>(); foreach (IDrawObject obj in objects) { IDrawObject newobj = obj.Clone(); newobjects.Add(newobj); newobj.Move(offset); ((DrawingLayer)ActiveLayer).AddObject(newobj); AddSelectedObject(newobj); } if (m_undoBuffer.CanCapture) m_undoBuffer.AddCommand(new EditCommandAdd(ActiveLayer, newobjects)); }
protected override void OnMouseUp(MouseEventArgs e) { base.OnMouseUp(e); if (e.Button == MouseButtons.Right) { CommandEscape(); } if (m_commandType == eCommandType.pan) { m_panOffset.X += m_dragOffset.X; m_panOffset.Y += m_dragOffset.Y; m_dragOffset = new PointF(0, 0); } List <IDrawObject> hitlist = null; Rectangle screenSelRect = Rectangle.Empty; if (m_selection != null) { screenSelRect = m_selection.ScreenRect(); RectangleF selectionRect = m_selection.Selection(m_canvaswrapper); if (selectionRect != RectangleF.Empty) { // is any selection rectangle. use it for selection hitlist = m_model.GetHitObjects(m_canvaswrapper, selectionRect, m_selection.AnyPoint()); DoInvalidate(true); } else { // else use mouse point UnitPoint mousepoint = ToUnit(new PointF(e.X, e.Y)); hitlist = m_model.GetHitObjects(m_canvaswrapper, mousepoint); HitUtil.ActivateSymbolAtPoint(m_canvaswrapper, hitlist, mousepoint); } m_selection = null; } if (m_commandType == eCommandType.select) { if (hitlist != null) { HandleSelection(hitlist); } } if (m_commandType == eCommandType.edit && m_editTool != null) { UnitPoint mousepoint = ToUnit(m_mousedownPoint); if (m_snappoint != null) { mousepoint = m_snappoint.SnapPoint; } if (screenSelRect != Rectangle.Empty) { m_editTool.SetHitObjects(mousepoint, hitlist); } m_editTool.OnMouseUp(m_canvaswrapper, mousepoint, m_snappoint); } if (m_commandType == eCommandType.draw && m_newObject != null) { UnitPoint mousepoint = ToUnit(m_mousedownPoint); if (m_snappoint != null) { mousepoint = m_snappoint.SnapPoint; } m_newObject.OnMouseUp(m_canvaswrapper, mousepoint, m_snappoint); } }
public List<IDrawObject> GetHitObjects(ICanvas canvas, UnitPoint point) { List<IDrawObject> selected = new List<IDrawObject>(); foreach (ICanvasLayer layer in m_layers) { if (layer.Visible == false) continue; foreach (IDrawObject drawobject in layer.Objects) { if (drawobject.PointInObject(canvas, point)) selected.Add(drawobject); } } return selected; }
protected override void OnMouseMove(MouseEventArgs e) { base.OnMouseMove(e); if (m_selection != null) { Graphics dc = Graphics.FromHwnd(Handle); m_selection.SetMousePoint(dc, new PointF(e.X, e.Y)); dc.Dispose(); return; } if (m_commandType == eCommandType.pan && (e.Button == MouseButtons.Left || e.Button == MouseButtons.Middle)) { m_dragOffset.X = -(m_mousedownPoint.X - e.X); m_dragOffset.Y = -(m_mousedownPoint.Y - e.Y); m_lastCenterPoint = CenterPointUnit(); DoInvalidate(true); } UnitPoint mousepoint; UnitPoint unitpoint = ToUnit(new PointF(e.X, e.Y)); if (m_commandType == eCommandType.draw || m_commandType == eCommandType.move || m_nodeMoveHelper.IsEmpty == false) { Rectangle invalidaterect = Rectangle.Empty; ISnapPoint newsnap = null; mousepoint = GetMousePoint(); if (RunningSnapsEnabled) { newsnap = m_model.SnapPoint(m_canvaswrapper, mousepoint, m_runningSnapTypes, null); } if (newsnap == null) { newsnap = m_model.GridLayer.SnapPoint(m_canvaswrapper, mousepoint, null); } if ((m_snappoint != null) && ((newsnap == null) || (newsnap.SnapPoint != m_snappoint.SnapPoint) || m_snappoint.GetType() != newsnap.GetType())) { invalidaterect = ScreenUtils.ConvertRect(ScreenUtils.ToScreenNormalized(m_canvaswrapper, m_snappoint.BoundingRect)); invalidaterect.Inflate(2, 2); RepaintStatic(invalidaterect); // remove old snappoint m_snappoint = newsnap; } if (m_commandType == eCommandType.move) { Invalidate(invalidaterect); } if (m_snappoint == null) { m_snappoint = newsnap; } } m_owner.SetPositionInfo(unitpoint); m_owner.SetSnapInfo(m_snappoint); //UnitPoint mousepoint; if (m_snappoint != null) { mousepoint = m_snappoint.SnapPoint; } else { mousepoint = GetMousePoint(); } if (m_newObject != null) { Rectangle invalidaterect = ScreenUtils.ConvertRect(ScreenUtils.ToScreenNormalized(m_canvaswrapper, m_newObject.GetBoundingRect(m_canvaswrapper))); invalidaterect.Inflate(2, 2); RepaintStatic(invalidaterect); m_newObject.OnMouseMove(m_canvaswrapper, mousepoint); RepaintObject(m_newObject); } if (m_snappoint != null) { RepaintSnappoint(m_snappoint); } if (m_moveHelper.HandleMouseMoveForMove(mousepoint)) { Refresh(); //Invalidate(); } RectangleF rNoderect = m_nodeMoveHelper.HandleMouseMoveForNode(mousepoint); if (rNoderect != RectangleF.Empty) { Rectangle invalidaterect = ScreenUtils.ConvertRect(ScreenUtils.ToScreenNormalized(m_canvaswrapper, rNoderect)); RepaintStatic(invalidaterect); CanvasWrapper dc = new CanvasWrapper(this, Graphics.FromHwnd(Handle), ClientRectangle); dc.Graphics.Clip = new Region(ClientRectangle); //m_nodeMoveHelper.DrawOriginalObjects(dc, rNoderect); m_nodeMoveHelper.DrawObjects(dc, rNoderect); if (m_snappoint != null) { RepaintSnappoint(m_snappoint); } dc.Graphics.Dispose(); dc.Dispose(); } }
public void MoveNodes(UnitPoint position, IEnumerable<INodePoint> nodes) { if (m_undoBuffer.CanCapture) m_undoBuffer.AddCommand(new EditCommandNodeMove(nodes)); foreach (INodePoint node in nodes) { node.SetPosition(position); node.Finish(); } }
public RectangleF HandleMouseMoveForNode(UnitPoint mouseunitpoint) { RectangleF r = RectangleF.Empty; if (m_nodes.Count == 0) return r; r = new RectangleF(m_originPoint.Point, new Size(0,0)); r = RectangleF.Union(r, new RectangleF(mouseunitpoint.Point, new SizeF(0,0))); if (m_lastPoint != UnitPoint.Empty) r = RectangleF.Union(r, new RectangleF(m_lastPoint.Point, new SizeF(0, 0))); m_lastPoint = mouseunitpoint; foreach (INodePoint p in m_nodes) { if (r == RectangleF.Empty) r = p.GetClone().GetBoundingRect(m_canvas); else r = RectangleF.Union(r, p.GetClone().GetBoundingRect(m_canvas)); p.SetPosition(mouseunitpoint); //m_canvas.RepaintObject(p.GetClone()); } return r; }
public ISnapPoint SnapPoint(ICanvas canvas, UnitPoint point, Type[] runningsnaptypes, Type usersnaptype) { List<IDrawObject> objects = GetHitObjects(canvas, point); if (objects.Count == 0) return null; foreach (IDrawObject obj in objects) { ISnapPoint snap = obj.SnapPoint(canvas, point, objects, runningsnaptypes, usersnaptype); if (snap != null) return snap; } return null; }
public static bool IsPointInRect(UnitPoint center, float rectHalfWidth, float rectHalfHeight, UnitPoint testpoint, float halflinewidth) { double distX = Math.Abs(center.X - testpoint.X); double distY = Math.Abs(center.Y - testpoint.Y); if ((distX >= rectHalfWidth - halflinewidth) && (distX <= rectHalfWidth + halflinewidth) && testpoint.Y <= center.Y + halflinewidth + rectHalfHeight && testpoint.Y >= center.Y - halflinewidth - rectHalfHeight) { return(true); } if ((distY >= rectHalfHeight - halflinewidth) && (distY <= rectHalfHeight + halflinewidth) && testpoint.X <= center.X + rectHalfWidth + halflinewidth && testpoint.X >= center.X - rectHalfWidth - halflinewidth) { return(true); } return(false); }