//! input frame is in World coordinates!
public SnapResult FindNearestSnapPointS(Frame3f fScene, float fMaxRadiusS)
{
float fNearestSqr = float.PositiveInfinity;
ISnapPoint hitO = null;
float fRSqr = fMaxRadiusS * fMaxRadiusS;
int min_priority = int.MaxValue;
foreach (var pt in Points)
{
if (pt.IsEnabled() == false)
{
continue;
}
float d = (fScene.Origin - pt.FrameS.Origin).LengthSquared;
if (d < fRSqr)
{
if (d < fNearestSqr || (pt.Priority < min_priority && MathUtil.EpsilonEqual(d, fNearestSqr, 0.0001f)))
{
fNearestSqr = d;
hitO = pt;
min_priority = pt.Priority;
}
}
}
return((hitO != null) ? new SnapResult(hitO) : null);
}
public override void InitializeFromModel(UnitPoint unitPoint, ISnapPoint snapPoint)
{
this.LayerId = (int)GlobalModel.CurrentLayerId;
this.LeftTopPoint = this.RightBottomPoint = this.StartMovePoint = unitPoint;
this.OnMouseDown(null, unitPoint, snapPoint, null);
this.IsSelected = true;
}
public eDrawObjectMouseDown OnMouseDown(ICanvas canvas, UnitPoint point, ISnapPoint snappoint)
{
if (snappoint is SnapPointBase && snappoint.Owner is RectBase)
{
NodePointMultiConnectionLine.ePoint pointType = HitUtil.Distance(point, m_p1) < HitUtil.Distance(point, m_p2) ?
NodePointMultiConnectionLine.ePoint.P1 : NodePointMultiConnectionLine.ePoint.P2;
RectBase rect = snappoint.Owner as RectBase;
rect.AttachConnectionCrvNode(new NodePointMultiConnectionLine(this, pointType));
if (pointType == NodePointMultiConnectionLine.ePoint.P1)
{
m_p1 = point;
}
else
{
m_p2 = point;
}
return(eDrawObjectMouseDown.Done);
}
OnMouseMove(canvas, point);
Selected = false;
if (m_allPts == null || m_allPts.Count < 2)
{
return(eDrawObjectMouseDown.Cancel);
}
return(eDrawObjectMouseDown.Done);
}
public eDrawObjectMouseDownEnum OnMouseDown(ICanvas canvas, UnitPoint point, ISnapPoint snappoint)
{
try
{
Selected = false;
OnMouseMove(canvas, point);
if (m_curPoint == eCurrentPoint.p1)
{
m_curPoint = eCurrentPoint.p2;
return(eDrawObjectMouseDownEnum.Continue);
}
if (m_curPoint == eCurrentPoint.p2)
{
m_curPoint = eCurrentPoint.p3;
return(eDrawObjectMouseDownEnum.Continue);
}
if (m_curPoint == eCurrentPoint.p3)
{
m_curPoint = eCurrentPoint.p4;
return(eDrawObjectMouseDownEnum.Continue);
}
if (m_curPoint == eCurrentPoint.p4)
{
m_curPoint = eCurrentPoint.done;
return(eDrawObjectMouseDownEnum.Done);
}
return(eDrawObjectMouseDownEnum.Done);
}
catch (Exception ex)
{ throw ex; }
}
private void OnTriggerStay2D(Collider2D other)
{
if (Snapped)
{
return;
}
ISnapPoint snapPoint = other.GetComponent <ISnapPoint>();
if (snapPoint == null)
{
return;
}
if (snapPoint.Snapped)
{
return;
}
if (!AreOppositeDirections(snapDirection, snapPoint.GetSnapDirection()))
{
return;
}
_spriteRenderer.sprite = snappedSprite;
_triggeredSnapPoint = snapPoint;
}
public bool HandleMouseDown(UnitPoint mouseunitpoint, ref bool handled, ISnapPoint snapPt = null)
{
handled = false;
if (m_nodes.Count == 0) // no nodes selected yet
{
if (m_canvas.Model.SelectedCount > 0)
{
foreach (IDrawObject obj in m_canvas.Model.SelectedObjects)
{
INodePoint p = obj.NodePoint(m_canvas, mouseunitpoint);
if (p != null)
{
m_nodes.Add(p);
}
}
}
handled = m_nodes.Count > 0;
if (handled)
{
m_originPoint = mouseunitpoint;
}
return(handled);
}
// update selected nodes
m_canvas.Model.MoveNodes(mouseunitpoint, m_nodes);
MoveReferenceNodesOfRect(m_nodes, snapPt, mouseunitpoint);
m_nodes.Clear();
handled = true;
m_canvas.CanvasCtrl.DoInvalidate(true);
return(handled);
}
/// <summary>
/// 处理鼠标按下的绘图
/// </summary>
/// <param name="mouseunitpoint"></param>
/// <param name="snappoint"></param>
protected virtual void HandleMouseDownWhenDrawing(UnitPoint mouseunitpoint, ISnapPoint snappoint)
{
if (m_commandType != eCommandType.draw)
{
return;
}
if (m_newObject == null)
{
m_newObject = m_model.CreateObject(m_drawObjectId, mouseunitpoint, snappoint);
DoInvalidate(false, m_newObject.GetBoundingRect(m_canvaswrapper));
return;
}
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 override void InitializeFromModel(UnitPoint unitPoint, ISnapPoint snapPoint)
{
this.LayerId = (int)GlobalModel.CurrentLayerId;
this.centerPoint = this.hexagonPoints[0] = unitPoint;
this.CalculateKeyPoints();
this.OnMouseDown(null, unitPoint, snapPoint, null);
this.IsSelected = true;
}
void RepaintSnappoint(ISnapPoint snappoint)
{
if (snappoint == null)
{
return;
}
snappoint.Draw(mScreenDisplay);
}
public void SetSnapInfo(ISnapPoint snap)
{
m_snapHint = string.Empty;
if (snap != null)
{
m_snapHint = string.Format("Snap@{0}, {1}", snap.SnapPoint.PosAsString(), snap.GetType());
}
m_snapInfoLabel.Text = m_snapHint;
}
public override void InitializeFromModel(UnitPoint unitPoint, ISnapPoint snapPoint)
{
this.GroupParam.FigureSN = ++GlobalModel.TotalDrawObjectCount;
this.GroupParam.ShowSN = this.GroupParam.FigureSN;
this.LayerId = (int)GlobalModel.CurrentLayerId;
this.P1 = unitPoint;
this.OnMouseDown(null, unitPoint, snapPoint, null);
this.IsSelected = true;
}
public IDrawObject CreateObject(string type, UnitPoint point, ISnapPoint snapPoint)
{
DrawObjectBase drawObjectBase = this.CreateObject(type);
if (drawObjectBase != null)
{
drawObjectBase.InitializeFromModel(point, snapPoint);
}
return(drawObjectBase as IDrawObject);
}
public ISnapPoint SnapPoint(ICanvas canvas, UnitPoint point, List <IDrawObject> otherObject)
{
foreach (IDrawObject drawObject in otherObject)
{
ISnapPoint snapPoint = drawObject.SnapPoint(canvas, point, otherObject, null, null);
if (snapPoint != null)
{
return(snapPoint);
}
}
return(null);
}
private void UpdateAllSnapPoints(Transform parent)
{
Transform[] children = parent.GetComponentsInChildren <Transform>();
foreach (Transform transform in children)
{
ISnapPoint iSnapPoint = transform.GetComponent <ISnapPoint>();
if (iSnapPoint != null)
{
iSnapPoint.UpdateSnapPoints();
}
}
}
public ISnapPoint SnapPoint(ICanvas canvas, UnitPoint point, List <IDrawObject> otherobj)
{
foreach (IDrawObject obj in m_objects)
{
ISnapPoint sp = obj.SnapPoint(canvas, point, otherobj, null, null);
if (sp != null)
{
return(sp);
}
}
return(null);
}
/// <summary>
/// 在画布按照snappoint重画
/// </summary>
/// <param name="snappoint"></param>
void RepaintSnappoint(ISnapPoint snappoint)
{
if (snappoint == null)
{
return;
}
CanvasWrapper dc = new CanvasWrapper(this, Graphics.FromHwnd(Handle), ClientRectangle);
snappoint.Draw(dc);
dc.Graphics.Dispose();
dc.Dispose();
} /// <summary>
//! returned hitFrame is in Scene coordinates!
public SnapResult FindHitSnapPoint(Ray3f ray)
{
float fNearest = float.PositiveInfinity;
ISnapPoint hitO = null;
ISnapSegment hitSeg = null;
int min_priority = int.MaxValue;
foreach (var pt in Points)
{
if (!pt.IsEnabled())
{
continue;
}
float fHitDist;
if (pt.FindRayIntersection(ray, out fHitDist))
{
if (fHitDist < fNearest || (pt.Priority < min_priority && MathUtil.EpsilonEqual(fHitDist, fNearest, 0.0001f)))
{
fNearest = fHitDist;
hitO = pt;
min_priority = pt.Priority;
}
}
}
foreach (var seg in Segments)
{
if (!seg.IsEnabled())
{
continue;
}
float fHitDist;
if (seg.FindRayIntersection(ray, out fHitDist) && fHitDist < fNearest)
{
fNearest = fHitDist;
hitSeg = seg;
hitO = null;
}
}
if (hitO != null)
{
return(new SnapResult(hitO));
}
else if (hitSeg != null)
{
Vector3f snapPosW = hitSeg.FindSnapPoint(ray);
return(new SnapResult(hitSeg, scene.ToSceneP(snapPosW)));
}
return(null);
}
private void TrySnap(ISnapable snapable)
{
List <ISnapPoint> snapPoints = snapable.GetSnapPoints();
foreach (ISnapPoint snapPoint in snapPoints)
{
ISnapPoint targetSnapPoint = snapPoint.GetTriggeredSnapable();
if (targetSnapPoint != null && snapPoint.GetTransform().parent.parent != targetSnapPoint.GetTransform().parent.parent)
{
Snapsnapable(snapPoint, targetSnapPoint);
return;
}
}
}
/// <summary>
/// 快速处理
/// </summary>
/// <param name="e"></param>
void HandleQuickSnap(KeyEventArgs e)
{
if (m_commandType == eCommandType.select || m_commandType == eCommandType.pan)
{
return;
}
ISnapPoint p = null;
UnitPoint mousepoint = GetMousePoint();
if (m_QuickSnap.ContainsKey(e.KeyCode))
{
p = m_model.SnapPoint(m_canvaswrapper, mousepoint, null, m_QuickSnap[e.KeyCode]);
}
if (p == null)
{
return;
}
if (m_commandType == eCommandType.draw)
{
HandleMouseDownWhenDrawing(p.SnapPoint, p);
if (m_newObject != null)
{
m_newObject.OnMouseMove(m_canvaswrapper, GetMousePoint());
}
DoInvalidate(true);
e.Handled = true;
}
if (m_commandType == eCommandType.move)
{
m_moveHelper.HandleMouseDownForMove(p.SnapPoint, p);
e.Handled = true;
}
if (m_nodeMoveHelper.IsEmpty == false)
{
bool handled = false;
m_nodeMoveHelper.HandleMouseDown(p.SnapPoint, ref handled);
FinishNodeEdit();
e.Handled = true;
}
if (m_commandType == eCommandType.edit)
{
}
}
public void CommandEscape()
{
bool dirty = (m_newObject != null) || (m_snappoint != null);
m_newObject = null;
m_snappoint = null;
//if (m_editTool != null)
// m_editTool.Finished();
//m_editTool = null;
m_commandType = eCommandType.select;
//m_moveHelper.HandleCancelMove();
m_nodeMoveHelper.HandleCancelMove();
DoInvalidate(dirty);
//UpdateCursor();
}
void MoveReferenceNodesOfRect(List <INodePoint> selectedNodes, ISnapPoint snapPt, UnitPoint mouseunitpoint)
{
List <INodePoint> allConnectionCrvNodes = new List <INodePoint>();
List <UnitPoint> allNewPos = new List <UnitPoint>();
foreach (var curNode in selectedNodes)
{
DeattachConnectionNode(curNode);
IConnectionCurve connectionCrv = curNode.GetOriginal() as IConnectionCurve;
if (connectionCrv != null)
{
m_canvas.DataModel.TrySnapConnectCrvToRectShape(m_canvas, connectionCrv);
}
}
}
private void Snapsnapable(ISnapPoint selected, ISnapPoint target)
{
Transform selectedSnapPoint = selected.GetTransform();
Transform selectedSnapable = selectedSnapPoint.parent;
Transform selectedShapeContainer = selectedSnapable.parent;
Transform targetSnapPoint = target.GetTransform();
Transform targetSnapable = targetSnapPoint.parent;
Transform targetShapeContainer = targetSnapable.parent;
float xOffset = selectedSnapPoint.position.x - selectedSnapable.position.x;
float yOffset = selectedSnapPoint.position.y - selectedSnapable.position.y;
Vector2 targetPosition = new Vector2(targetSnapPoint.position.x - xOffset, targetSnapPoint.position.y - yOffset);
Vector2 startPos = selectedSnapable.position;
float xOffsetTotal = startPos.x - targetPosition.x;
float yOffsetTotal = startPos.y - targetPosition.y;
//Move to target BlockContainer
foreach (ISnapable snapable in selectedShapeContainer.GetComponentsInChildren <ISnapable>())
{
Transform shape = snapable.Transform;
shape.parent = targetShapeContainer;
Vector3 position = shape.position;
position = new Vector2(position.x - xOffsetTotal, position.y - yOffsetTotal);
shape.position = position;
}
targetShapeContainer.GetComponent <IShapeContainer>().PrepareStart();
//Destroy old Container
selectedShapeContainer.GetComponent <IShapeContainer>().Destroy();
_snapForest.Join(
selected.GetTransform().parent.GetComponent <Snapable>(),
target.GetTransform().parent.GetComponent <Snapable>()
);
//Deactivates used Snapables
selected.SetSnapped();
target.SetSnapped();
if (_snapSound == null)
{
PrepareSnapSound( );
}
_snapSound.Play();
}
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);
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:
IDrawObject addedObj = m_model.AddObject(m_model.ActiveLayer, m_newObject);
if (m_newObject is IConnectionCurve)
{
m_model.TrySnapConnectCrvToRectShape(m_canvaswrapper, (IConnectionCurve)addedObj);
}
m_newObject = null;
DoInvalidate(true);
break;
case eDrawObjectMouseDown.DoneRepeat:
addedObj = m_model.AddObject(m_model.ActiveLayer, m_newObject);
if (addedObj is IConnectionCurve)
{
m_model.TrySnapConnectCrvToRectShape(m_canvaswrapper, (IConnectionCurve)addedObj);
}
m_newObject = m_model.CreateObject(m_newObject.Id, m_newObject.RepeatStartingPoint, null);
DoInvalidate(true);
break;
case eDrawObjectMouseDown.Continue:
break;
case eDrawObjectMouseDown.Cancel:
m_newObject = null;
DoInvalidate(true);
break;
}
}
}
}
}
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 DrawObjectMouseDown OnMouseDown(ICanvas canvas, UnitPoint point, ISnapPoint snapPoint, MouseEventArgs e)
{
OnMouseMove(canvas, point);
if (this.DrawPoint == CurrentDrawPoint.First)
{
this.DrawPoint = CurrentDrawPoint.Second;
return(DrawObjectMouseDown.Continue);
}
else
{
this.IsSelected = false;
this.SN = ++GlobalModel.TotalDrawObjectCount;
this.drawStatus = DrawObjectMouseDown.Done;
return(DrawObjectMouseDown.Done);
}
}
public eDrawObjectMouseDown OnMouseDown(ICanvas canvas, UnitPoint point, ISnapPoint snappoint)
{
OnMouseMove(canvas, point);
if (CurrentPoint == eCurrentPoint.p1)
{
CurrentPoint = eCurrentPoint.p3;
return(eDrawObjectMouseDown.Continue);
}
if (CurrentPoint == eCurrentPoint.p3)
{
CurrentPoint = eCurrentPoint.done;
OnMouseMove(canvas, point);
Selected = false;
return(eDrawObjectMouseDown.Done);
}
return(eDrawObjectMouseDown.Done);
}
private void OnTriggerExit2D(Collider2D other)
{
if (Snapped)
{
return;
}
ISnapPoint snapPoint = other.GetComponent <ISnapPoint>();
if (snapPoint == null)
{
return;
}
_spriteRenderer.sprite = _baseSprite;
_triggeredSnapPoint = null;
}
public void HandleMouseDownForMove(UnitPoint mouseunitpoint, ISnapPoint snappoint)
{
UnitPoint p = mouseunitpoint;
if (snappoint != null)
{
p = snappoint.SnapPoint;
}
if (m_originals.Count == 0) // first step of move
{
foreach (IDrawObject obj in m_canvas.Model.SelectedObjects)
{
m_originals.Add(obj);
m_copies.Add(obj.Clone());
}
m_canvas.Model.ClearSelectedObjects();
m_originPoint = p;
m_lastPoint = p;
}
else // move complete
{
double x = p.X - m_originPoint.X;
double y = p.Y - m_originPoint.Y;
UnitPoint offset = new UnitPoint(x, y);
// do copy
if ((Control.ModifierKeys & Keys.Control) == Keys.Control)
{
m_canvas.Model.CopyObjects(offset, m_originals);
}
else
{
// do move
m_canvas.Model.MoveObjects(offset, m_originals);
foreach (IDrawObject obj in m_originals)
{
m_canvas.Model.AddSelectedObject(obj);
}
}
m_originals.Clear();
m_copies.Clear();
}
m_canvas.DoInvalidate(true);
}
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 DrawObjectMouseDown OnMouseDown(ICanvas canvas, UnitPoint point, ISnapPoint snapPoint, MouseEventArgs e)
{
OnMouseMove(canvas, point);
if (this.currentPoint == CurrentPoint.CenterPoint)
{
this.currentPoint = CurrentPoint.StartPoint;
return(DrawObjectMouseDown.Continue);
}
if (this.currentPoint == CurrentPoint.StartPoint)
{
//OnMouseMove(canvas, point);
this.IsSelected = false;
this.startMovePoint = this.hexagonPoints[0];
this.drawStatus = DrawObjectMouseDown.Done;
this.SN = ++GlobalModel.TotalDrawObjectCount;
return(DrawObjectMouseDown.Done);
}
return(DrawObjectMouseDown.Done);
}
public override void InitializeFromModel(UnitPoint point, DrawingLayer layer, ISnapPoint snap)
{
Width = layer.Width;
Color = layer.Color;
OnMouseDown(null, point, snap);
Selected = true;
}
public override eDrawObjectMouseDown OnMouseDown(ICanvas canvas, UnitPoint point, ISnapPoint snappoint)
{
OnMouseMove(canvas, point);
if (m_arcType == eArcType.type2point)
{
if (m_curPoint == eCurrentPoint.p1)
{
m_curPoint = eCurrentPoint.p2;
return eDrawObjectMouseDown.Continue;
}
if (m_curPoint == eCurrentPoint.p2)
{
m_curPoint = eCurrentPoint.done;
OnMouseMove(canvas, point);
Selected = false;
return eDrawObjectMouseDown.Done;
}
}
if (m_arcType == eArcType.typeCenterRadius)
{
if (m_curPoint == eCurrentPoint.center)
{
m_curPoint = eCurrentPoint.radius;
return eDrawObjectMouseDown.Continue;
}
if (m_curPoint == eCurrentPoint.radius)
{
m_curPoint = eCurrentPoint.done;
OnMouseMove(canvas, point);
Selected = false;
return eDrawObjectMouseDown.Done;
}
}
return eDrawObjectMouseDown.Done;
}
public override void InitializeFromModel(UnitPoint point, DrawingLayer layer, ISnapPoint snap)
{
FromPoint = StartPoint = EndPoint = ToPoint = point;
int count = 1;
foreach (IDrawObject i in layer.Objects) if (i.GetType() == this.GetType()) count++;
foreach (Property p in properties) if (p.name == "name" && p.value == "") p.value = this.Id + count;
Width = layer.Width;
Color = layer.Color;
Selected = true;
}
public eDrawObjectMouseDown OnMouseDown(ICanvas canvas, UnitPoint point, ISnapPoint snappoint)
{
List<IDrawObject> drawitems = canvas.DataModel.GetHitObjects(canvas, point);
List<DrawTools.Line> lines = GetLines(drawitems);
// add to source lines
if (m_originalLines.Count == 0 || Control.ModifierKeys == Keys.Shift)
{
foreach (DrawTools.Line line in lines)
AddLine(point, line);
SetSelectHint();
return eDrawObjectMouseDown.Continue;
}
if (m_originalLines.Count == 0 || Control.ModifierKeys == Keys.Control)
{
foreach (DrawTools.Line line in lines)
{
if (m_originalLines.ContainsKey(line))
RemoveLine(line);
else
AddLine(point, line);
}
SetSelectHint();
return eDrawObjectMouseDown.Continue;
}
if (drawitems.Count == 0)
return eDrawObjectMouseDown.Continue;
// all lines have been added, now find edge to where to extend
if (drawitems[0] is DrawTools.Line)
{
DrawTools.Line edge = (DrawTools.Line)drawitems[0];
bool modified = false;
foreach (LinePoints originalLp in m_originalLines.Values)
{
UnitPoint intersectpoint = HitUtil.LinesIntersectPoint(edge.P1, edge.P2, originalLp.Line.P1, originalLp.Line.P2);
// lines intersect so shrink line
if (intersectpoint != UnitPoint.Empty)
{
LinePoints lp = new LinePoints();
lp.SetLine(originalLp.Line);
lp.MousePoint = originalLp.MousePoint;
m_modifiedLines.Add(lp.Line, lp);
lp.SetNewPoints(lp.Line, lp.MousePoint, intersectpoint);
modified = true;
continue;
}
// lines do not intersect, find apparent intersect point on existing edge line
if (intersectpoint == UnitPoint.Empty)
{
UnitPoint apprarentISPoint = HitUtil.FindApparentIntersectPoint(
edge.P1,
edge.P2,
originalLp.Line.P1,
originalLp.Line.P2,
false,
true);
if (apprarentISPoint == UnitPoint.Empty)
continue;
modified = true;
originalLp.Line.ExtendLineToPoint(apprarentISPoint);
LinePoints lp = new LinePoints();
lp.SetLine(originalLp.Line);
lp.MousePoint = point;
m_modifiedLines.Add(lp.Line, lp);
}
}
if (modified)
canvas.DataModel.AfterEditObjects(this);
return eDrawObjectMouseDown.Done;
}
if (drawitems[0] is DrawTools.Arc)
{
DrawTools.Arc edge = (DrawTools.Arc)drawitems[0];
foreach (LinePoints originalLp in m_originalLines.Values)
{
}
bool modified = false;
}
return eDrawObjectMouseDown.Done;
}
public virtual eDrawObjectMouseDown OnMouseDown(ICanvas canvas, UnitPoint point, ISnapPoint snappoint)
{
if (!tofrom && !child)
{
foreach (IDrawObject i in canvas.DataModel.GetHitObjects(canvas, point)) if (i.GetType().ToString().IndexOf("Module") >= 0 && i != this)
{
from_connections = (ModuleItems.Module)i;
if (from_connections.ToPoint == point) foreach (Property p in from_connections.properties) if (p.name == "to") foreach (Property q in properties) if (q.name == "name") p.value = q.value;
if (from_connections.FromPoint == point) foreach (Property p in from_connections.properties) if (p.name == "from") foreach (Property q in properties) if (q.name == "name") p.value = q.value;
}
return eDrawObjectMouseDown.Done;
}
if (currentPoint == ePoint.FromPoint)
{
m_p1 = point;
currentPoint = ePoint.StartPoint;
foreach (IDrawObject i in canvas.DataModel.GetHitObjects(canvas, point)) if (i.GetType().ToString().IndexOf("Module") >= 0 && i != this) from_connections = (ModuleItems.Module)i;
if (from_connections != null) foreach (Property p in properties) if (p.name == "from") foreach (Property q in from_connections.properties) if (q.name == "name") p.value = q.value;
if (from_connections != null && child) foreach (Property p in properties) if (p.name == "parent") foreach (Property q in from_connections.properties) if (q.name == "name") p.value = q.value;
return eDrawObjectMouseDown.Continue;
}
if (currentPoint == ePoint.StartPoint)
{
currentPoint = ePoint.EndPoint;
if (snappoint is PerpendicularSnapPoint && snappoint.Owner is Module)
{
Module src = snappoint.Owner as Module;
m_p2 = HitUtil.NearestPointOnLine(src.FromPoint, src.EndPoint, m_p1, true);
if (horizontal) m_p3 = new UnitPoint(m_p2.X + 1, m_p2.Y);
else m_p3 = new UnitPoint(m_p2.X, m_p2.Y - 1);
if (child) return eDrawObjectMouseDown.Done;
return eDrawObjectMouseDown.Continue;
}
if (snappoint is PerpendicularSnapPoint && snappoint.Owner is Canvas.DrawTools.Line)
{
Canvas.DrawTools.Line src = snappoint.Owner as Canvas.DrawTools.Line;
m_p2 = HitUtil.NearestPointOnLine(src.P1, src.P2, m_p1, true);
if (horizontal) m_p3 = new UnitPoint(m_p2.X + 1, m_p2.Y);
else m_p3 = new UnitPoint(m_p2.X, m_p2.Y - 1);
if (child) return eDrawObjectMouseDown.Done;
return eDrawObjectMouseDown.Continue;
}
if (snappoint is PerpendicularSnapPoint && snappoint.Owner is Canvas.DrawTools.Arc)
{
Canvas.DrawTools.Arc src = snappoint.Owner as Canvas.DrawTools.Arc;
m_p2 = HitUtil.NearestPointOnCircle(src.Center, src.Radius, m_p1, 0);
if (horizontal) m_p3 = new UnitPoint(m_p2.X + 1, m_p2.Y);
else m_p3 = new UnitPoint(m_p2.X, m_p2.Y - 1);
if (child) return eDrawObjectMouseDown.Done;
return eDrawObjectMouseDown.Continue;
}
if (Control.ModifierKeys == Keys.Control)
point = HitUtil.OrthoPointD(m_p1, point, 45);
m_p2 = point;
if (horizontal) m_p3 = new UnitPoint(m_p2.X + 1, m_p2.Y);
else m_p3 = new UnitPoint(m_p2.X, m_p2.Y - 1);
if (child) return eDrawObjectMouseDown.Done;
return eDrawObjectMouseDown.Continue;
}
Selected = false;
currentPoint = ePoint.ToPoint;
if (snappoint is PerpendicularSnapPoint && snappoint.Owner is Module)
{
Module src = snappoint.Owner as Module;
m_p4 = HitUtil.NearestPointOnLine(src.FromPoint, src.EndPoint, m_p3, true);
return eDrawObjectMouseDown.Done;
}
if (snappoint is PerpendicularSnapPoint && snappoint.Owner is Canvas.DrawTools.Line)
{
Canvas.DrawTools.Line src = snappoint.Owner as Canvas.DrawTools.Line;
m_p4 = HitUtil.NearestPointOnLine(src.P1, src.P2, m_p3, true);
return eDrawObjectMouseDown.Done;
}
if (snappoint is PerpendicularSnapPoint && snappoint.Owner is Canvas.DrawTools.Arc)
{
Canvas.DrawTools.Arc src = snappoint.Owner as Canvas.DrawTools.Arc;
m_p4 = HitUtil.NearestPointOnCircle(src.Center, src.Radius, m_p3, 0);
return eDrawObjectMouseDown.Done;
}
if (Control.ModifierKeys == Keys.Control)
point = HitUtil.OrthoPointD(m_p1, point, 45);
m_p4 = point;
foreach (IDrawObject i in canvas.DataModel.GetHitObjects(canvas, point)) if (i.GetType().ToString().IndexOf("Module") >= 0 && i != this) to_connections = (ModuleItems.Module)i;
if (to_connections != null) foreach (Property p in properties) if (p.name == "to") foreach (Property q in to_connections.properties) if (q.name == "name") p.value = q.value;
return eDrawObjectMouseDown.Done;
}
public void HandleMouseDownForMove(UnitPoint mouseunitpoint, ISnapPoint snappoint)
{
UnitPoint p = mouseunitpoint;
if (snappoint != null)
p = snappoint.SnapPoint;
if (m_originals.Count == 0) // first step of move
{
foreach (IDrawObject obj in m_canvas.Model.SelectedObjects)
{
m_originals.Add(obj);
m_copies.Add(obj.Clone());
}
m_canvas.Model.ClearSelectedObjects();
m_originPoint = p;
m_lastPoint = p;
}
else // move complete
{
double x = p.X - m_originPoint.X;
double y = p.Y - m_originPoint.Y;
UnitPoint offset = new UnitPoint(x, y);
// do copy
if ((Control.ModifierKeys & Keys.Control) == Keys.Control)
{
m_canvas.Model.CopyObjects(offset, m_originals);
}
else
{
// do move
m_canvas.Model.MoveObjects(offset, m_originals);
foreach (IDrawObject obj in m_originals)
m_canvas.Model.AddSelectedObject(obj);
}
m_originals.Clear();
m_copies.Clear();
}
m_canvas.DoInvalidate(true);
}
public eDrawObjectMouseDown OnMouseDown(ICanvas canvas, UnitPoint point, ISnapPoint snappoint)
{
List<IDrawObject> items = canvas.DataModel.GetHitObjects(canvas, point);
DrawTools.Line line = null;
// find first line
foreach (IDrawObject item in items)
{
if (item is DrawTools.Line)
{
line = item as DrawTools.Line;
if (line != m_l1Original.Line)
break;
}
}
if (line == null)
{
if (m_l1Original.Line == null)
SetHint("No line selected. Select first line");
else
SetHint("No line selected. Select second line");
return eDrawObjectMouseDown.Continue;
}
if (m_l1Original.Line == null)
{
line.Highlighted = true;
m_l1Original.SetLine(line);
m_l1Original.MousePoint = point;
SetHint("Select second line");
return eDrawObjectMouseDown.Continue;
}
if (m_l2Original.Line == null)
{
line.Highlighted = true;
m_l2Original.SetLine(line);
m_l2Original.MousePoint = point;
UnitPoint intersectpoint = HitUtil.LinesIntersectPoint(
m_l1Original.Line.P1,
m_l1Original.Line.P2,
m_l2Original.Line.P1,
m_l2Original.Line.P2);
// if lines do not intersect then extend lines to intersect point
if (intersectpoint == UnitPoint.Empty)
{
UnitPoint apprarentISPoint = HitUtil.FindApparentIntersectPoint(m_l1Original.Line.P1, m_l1Original.Line.P2, m_l2Original.Line.P1, m_l2Original.Line.P2);
if (apprarentISPoint == UnitPoint.Empty)
return eDrawObjectMouseDown.Done;
m_l1Original.Line.ExtendLineToPoint(apprarentISPoint);
m_l2Original.Line.ExtendLineToPoint(apprarentISPoint);
m_l1NewPoint.SetLine(m_l1Original.Line);
m_l2NewPoint.SetLine(m_l2Original.Line);
canvas.DataModel.AfterEditObjects(this);
return eDrawObjectMouseDown.Done;
}
m_l1NewPoint.SetNewPoints(m_l1Original.Line, m_l1Original.MousePoint, intersectpoint);
m_l2NewPoint.SetNewPoints(m_l2Original.Line, m_l2Original.MousePoint, intersectpoint);
canvas.DataModel.AfterEditObjects(this);
return eDrawObjectMouseDown.Done;
}
return eDrawObjectMouseDown.Done;
}
protected override void OnMouseDown(MouseEventArgs e)
{
m_mousedownPoint = new PointF(e.X, e.Y); // used when panning
m_dragOffset = new PointF(0,0);
if (e.Button == System.Windows.Forms.MouseButtons.Right) CommandEscape();
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;
}
DoInvalidate(true);
UpdateCursor();
m_selection = new SelectionRectangle(m_mousedownPoint);
}
if (m_commandType == eCommandType.move)
{
m_moveHelper.HandleMouseDownForMove(mousepoint, m_snappoint);
}
if (m_commandType == eCommandType.draw)
{
if (e.Button == System.Windows.Forms.MouseButtons.Middle && m_newObject != null)
{
if (m_newObject is ModuleItems.Module) (m_newObject as ModuleItems.Module).horizontal = !(m_newObject as ModuleItems.Module).horizontal;
return;
}
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);
}
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;
}
}
}
}
}
void RepaintSnappoint(ISnapPoint snappoint)
{
if (snappoint == null)
return;
CanvasWrapper dc = new CanvasWrapper(this, Graphics.FromHwnd(Handle), ClientRectangle);
snappoint.Draw(dc);
dc.Graphics.Dispose();
dc.Dispose();
}
protected override void OnMouseDown(MouseEventArgs e)
{
m_mousedownPoint = new PointF(e.X, e.Y); // used when panning
m_dragOffset = new PointF(0, 0);
//移动音符放下
if (moving)
{
moving = false;
lines.AddRange(mr.getLines());
}
if (ispaste)
{
ispaste = false;
List<Line> l=pr.getLines();
for (int i = 0; i <l.Count; i++) {
Line l1 = new Line(l[i].P1, l[i].P2, l[i].S, l[i].isRed, l[i].Color);
lines.Add(l1);
}
}
if (m_drawObjectId.Equals("StartPoint")) {
TestForm.setStartPoint(e.X,e.Y);
}
UnitPoint mousepoint = ToUnit(m_mousedownPoint);
if (m_snappoint != null)
mousepoint = m_snappoint.SnapPoint;
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);
}
else if (m_commandType == eCommandType.symbol) {
System.ComponentModel.ComponentResourceManager resources = new System.ComponentModel.ComponentResourceManager(typeof(TestForm));
CanvasWrapper canvastest = new CanvasWrapper(this, Graphics.FromImage(m_staticImage), ClientRectangle);
canvastest.Graphics.SmoothingMode = m_smoothingMode;
if (m_drawObjectId == "clef1" || m_drawObjectId == "clef2" || m_drawObjectId == "clef3" || m_drawObjectId == "clef4" || m_drawObjectId == "clef6" || m_drawObjectId == "N2"
|| m_drawObjectId == "N3" || m_drawObjectId == "N4" || m_drawObjectId == "N5" || m_drawObjectId == "N6" || m_drawObjectId == "N7" || m_drawObjectId == "N8" || m_drawObjectId == "N9"
|| m_drawObjectId == "N10" || m_drawObjectId == "N11" || m_drawObjectId == "N12" || m_drawObjectId == "s10" || m_drawObjectId == "s11" || m_drawObjectId == "s12" ||
m_drawObjectId == "N12" || m_drawObjectId == "N13" )
{
// MessageBox.Show("test test " + m_drawObjectId);
DrawSymbol(canvastest, e.X, e.Y, ((System.Drawing.Image)(resources.GetObject("ribbonButton_" + m_drawObjectId + ".Image"))), 1);
}
else if (m_drawObjectId == "bm1" || m_drawObjectId == "bm2" || m_drawObjectId == "bm3" || m_drawObjectId == "bm4"
|| m_drawObjectId == "bm5" || m_drawObjectId == "bm6" || m_drawObjectId == "bm7" || m_drawObjectId == "bm8" ||
m_drawObjectId == "bm18" || m_drawObjectId == "o11")
{
DrawSymbol(canvastest, e.X, e.Y, ((System.Drawing.Image)(resources.GetObject("ribbonButton_" + m_drawObjectId + ".Image"))), 0.7);
}
else
{
// MessageBox.Show("test test " + m_drawObjectId);
DrawSymbol(canvastest, e.X, e.Y, ((System.Drawing.Image)(resources.GetObject("ribbonButton_" + m_drawObjectId + ".Image"))), 0.4);
}
canvastest.CanvasCtrl.Refresh();
}
/*
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 CommandEscape()
{
bool dirty = (m_newObject != null) || (m_snappoint != null);
m_newObject = null;
m_snappoint = null;
//if (m_editTool != null)
// m_editTool.Finished();
//m_editTool = null;
m_commandType = eCommandType.select;
//m_moveHelper.HandleCancelMove();
m_nodeMoveHelper.HandleCancelMove();
DoInvalidate(dirty);
//UpdateCursor();
}
public void OnMouseUp(ICanvas canvas, UnitPoint point, ISnapPoint snappoint)
{
//Draw(canvas,new RectangleF());
}
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 (moving) //如果有选中的区域正在移动
{
Invalidate();
mr.moving(e.X - lastX, e.Y - lastY);
lastX = e.X;
lastY = e.Y;
}
if (ispaste) //如果有选中的区域正在移动
{
Invalidate();
pr.moving(e.X - lastX, e.Y - lastY);
lastX = e.X;
lastY = e.Y;
}
UnitPoint mousepoint;
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;
}
//////////////////////////////////////////////////////////////////////////
//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();
}
*/
}
void FinishNodeEdit()
{
m_commandType = eCommandType.select;
m_snappoint = null;
}
public void CommandSelectEraserTool(string drawobjectid)
{
bool dirty = (m_newObject != null) || (m_snappoint != null);
m_newObject = null;
m_snappoint = null;
//if (m_editTool != null)
// m_editTool.Finished();
//m_editTool = null;
m_commandType = eCommandType.select;
//m_moveHelper.HandleCancelMove();
m_drawObjectId = drawobjectid;
m_nodeMoveHelper.HandleCancelMove();
DoInvalidate(dirty);
ispaste = false;
moving = false;
if(drawobjectid.Equals("Paste")){
ispaste = true;
}
//UpdateCursor();
}
public override void InitializeFromModel(UnitPoint point, DrawingLayer layer, ISnapPoint snap)
{
P1 = P2 = point;
Width = layer.Width;
Color = layer.Color;
Selected = true;
}
eDrawObjectMouseDown MouseDown3P132(ICanvas canvas, UnitPoint point, ISnapPoint snappoint)
{
OnMouseMove(canvas, point);
if (m_curPoint == eCurrentPoint.p1)
{
m_curPoint = eCurrentPoint.p3;
return eDrawObjectMouseDown.Continue;
}
if (m_curPoint == eCurrentPoint.p3)
{
m_curPoint = eCurrentPoint.p2;
return eDrawObjectMouseDown.Continue;
}
if (m_curPoint == eCurrentPoint.p2)
{
m_curPoint = eCurrentPoint.done;
Selected = false;
return eDrawObjectMouseDown.Done;
}
return eDrawObjectMouseDown.Done;
}
public virtual eDrawObjectMouseDown OnMouseDown(ICanvas canvas, UnitPoint point, ISnapPoint snappoint)
{
Selected = false;
if (snappoint is PerpendicularSnapPoint && snappoint.Owner is Line)
{
Line src = snappoint.Owner as Line;
m_p2 = HitUtil.NearestPointOnLine(src.P1, src.P2, m_p1, true);
return eDrawObjectMouseDown.DoneRepeat;
}
/*
if (snappoint is PerpendicularSnapPoint && snappoint.Owner is Arc)
{
Arc src = snappoint.Owner as Arc;
m_p2 = HitUtil.NearestPointOnCircle(src.Center, src.Radius, m_p1, 0);
return eDrawObjectMouseDown.DoneRepeat;
}
* */
if (Control.ModifierKeys == Keys.Control)
point = HitUtil.OrthoPointD(m_p1, point, 45);
m_p2 = point;
return eDrawObjectMouseDown.DoneRepeat;
}
public virtual eDrawObjectMouseDown OnMouseDown(ICanvas canvas, UnitPoint point, ISnapPoint snappoint)
{
if (m_type == eArcType.kArc3P132)
return MouseDown3P132(canvas, point, snappoint);
if (m_type == eArcType.kArc3P123)
return MouseDown3P123(canvas, point, snappoint);
return eDrawObjectMouseDown.Done;
}
public void OnMouseUp(ICanvas canvas, UnitPoint point, ISnapPoint snappoint)
{
}
public void CommandEscape()
{
bool dirty = (m_newObject != null) || (m_snappoint != null);
m_newObject = null;
m_snappoint = null;
if (m_editTool != null)
m_editTool.Finished();
m_editTool = null;
m_commandType = eCommandType.select;
m_moveHelper.HandleCancelMove();
m_nodeMoveHelper.HandleCancelMove();
if (this.Parent is DocumentForm){
DocumentForm temp = this.Parent as DocumentForm;
temp.SetHint("");
}
DoInvalidate(dirty);
UpdateCursor();
}
public override void InitializeFromModel(UnitPoint point, DrawingLayer layer, ISnapPoint snap)
{
base.InitializeFromModel(point, layer, snap);
m_perSnap = snap as PerpendicularSnapPoint;
m_tanSnap = snap as TangentSnapPoint;
}
protected override void OnKeyDown(KeyEventArgs e)
{
HandleQuickSnap(e);
if (m_nodeMoveHelper.IsEmpty == false)
{
m_nodeMoveHelper.OnKeyDown(m_canvaswrapper, e);
if (e.Handled)
return;
}
base.OnKeyDown(e);
if (e.Handled)
{
UpdateCursor();
return;
}
if (m_editTool != null)
{
m_editTool.OnKeyDown(m_canvaswrapper, e);
if (e.Handled)
return;
}
if (m_newObject != null)
{
m_newObject.OnKeyDown(m_canvaswrapper, e);
if (e.Handled)
return;
}
foreach (IDrawObject obj in m_model.SelectedObjects)
{
obj.OnKeyDown(m_canvaswrapper, e);
if (e.Handled)
return;
}
if ((Control.ModifierKeys & Keys.Control) == Keys.Control)
{
if (e.KeyCode == Keys.G)
{
m_model.GridLayer.Enabled = !m_model.GridLayer.Enabled;
DoInvalidate(true);
}
if (e.KeyCode == Keys.S)
{
RunningSnapsEnabled = !RunningSnapsEnabled;
if (!RunningSnapsEnabled)
m_snappoint = null;
DoInvalidate(false);
}
if (e.KeyCode == Keys.F)
{
if (this.Parent.Parent.Parent is Canvas.MainWin)
{
Canvas.MainWin temp = this.Parent.Parent.Parent as Canvas.MainWin;
temp.showFind();
}
DoInvalidate(false);
}
return;
}
if (e.KeyCode == Keys.Escape)
{
CommandEscape();
}
if (e.KeyCode == Keys.P)
{
CommandPan();
}
if (e.KeyCode == Keys.S)
{
RunningSnapsEnabled = !RunningSnapsEnabled;
if (!RunningSnapsEnabled)
m_snappoint = null;
DoInvalidate(false);
}
if (e.KeyCode >= Keys.D1 && e.KeyCode <= Keys.D9)
{
int layerindex = (int)e.KeyCode - (int)Keys.D1;
if (layerindex >=0 && layerindex < m_model.Layers.Length)
{
m_model.ActiveLayer = m_model.Layers[layerindex];
DoInvalidate(true);
}
}
if (e.KeyCode == Keys.Delete)
{
CommandDeleteSelected();
}
if (e.KeyCode == Keys.O)
{
CommandEdit("linesmeet");
}
UpdateCursor();
}
public override eDrawObjectMouseDown OnMouseDown(ICanvas canvas, UnitPoint point, ISnapPoint snappoint)
{
if (m_tanSnap != null && Control.MouseButtons == MouseButtons.Right)
{
ReverseTangent(canvas);
return eDrawObjectMouseDown.Continue;
}
if (m_perSnap != null || m_tanSnap != null)
{
if (snappoint != null)
point = snappoint.SnapPoint;
OnMouseMove(canvas, point);
if (m_singleLineSegment)
return eDrawObjectMouseDown.Done;
return eDrawObjectMouseDown.DoneRepeat;
}
eDrawObjectMouseDown result = base.OnMouseDown(canvas, point, snappoint);
if (m_singleLineSegment)
return eDrawObjectMouseDown.Done;
return eDrawObjectMouseDown.DoneRepeat;
}
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 void SetSnapInfo(ISnapPoint snap)
{
m_snapHint = string.Empty;
if (snap != null)
m_snapHint = string.Format("Snap@{0}, {1}", snap.SnapPoint.PosAsString(), snap.GetType());
m_snapInfoLabel.Text = m_snapHint;
}
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;
}
abstract public void InitializeFromModel(UnitPoint point, DrawingLayer layer, ISnapPoint snap);
