//--------------------------------------------------------------------------------------------------
public override bool OnMouseMove(MouseEventData data)
{
if (!IsFinished)
{
ProcessMouseInput(data);
if (_MarkerType != SelectedElementType)
{
_Marker?.Remove();
_Marker = null;
_MarkerType = Sketch.ElementType.None;
}
if (SelectedElementType != Sketch.ElementType.None)
{
if (_Marker == null)
{
_Marker = new Marker(WorkspaceController, Marker.Styles.Bitmap | Marker.Styles.Topmost,
SelectedElementType == Sketch.ElementType.Segment ? Marker.XImage : Marker.RingImage);
_Marker.SetColor(Colors.SketchEditorHighlight);
_MarkerType = SelectedElementType;
}
_Marker.Set(_SelectedPoint);
}
WorkspaceController.Invalidate();
return(base.OnMouseMove(data));
}
return(false);
}
//--------------------------------------------------------------------------------------------------
public override void Reset()
{
base.Reset();
SelectedElementType = Sketch.ElementType.None;
_Marker?.Remove();
_Marker = null;
_MarkerType = Sketch.ElementType.None;
}
//--------------------------------------------------------------------------------------------------
void _Sketch_ElementsChanged(Sketch sketch, Sketch.ElementType types)
{
if (sketch != Sketch)
{
return;
}
// Check for new ones
if (types.HasFlag(Sketch.ElementType.Point))
{
// Take over new points
_TempPoints = new Dictionary <int, Pnt2d>(Sketch.Points);
}
Elements.OnSketchChanged(Sketch, types);
_UpdateSelections();
}
//--------------------------------------------------------------------------------------------------
void Sketch_ElementsChanged(Sketch sketch, Sketch.ElementType types)
{
if (types.HasFlag(Sketch.ElementType.Point))
{
// Check for lost points
var lostPoints = Points.Where(i => !_Sketch.Points.ContainsKey(i)).ToArray();
foreach (var lostPoint in lostPoints)
{
Points.Remove(lostPoint);
}
if (!Points.Any())
{
RaiseFinished();
}
UpdateTrihedron();
}
}
AddElements(IDictionary <int, Pnt2d> points, int[] mergePointIndices, IDictionary <int, SketchSegment> segments, IEnumerable <SketchConstraint> constraints)
{
Sketch.ElementType changedTypes = 0;
Dictionary <int, int> pointMap = null;
Dictionary <int, int> segmentMap = null;
if (points != null)
{
pointMap = new Dictionary <int, int>(points.Count);
SaveUndo(ElementType.Point);
changedTypes |= ElementType.Point;
foreach (var pointKvp in points)
{
pointMap.Add(pointKvp.Key, (mergePointIndices != null) && (mergePointIndices[pointKvp.Key] >= 0) ? mergePointIndices[pointKvp.Key] : AddPoint(pointKvp.Value));
}
if (segments != null)
{
segmentMap = new Dictionary <int, int>();
SaveUndo(ElementType.Segment);
changedTypes |= ElementType.Segment;
foreach (var segmentKvp in segments)
{
var segment = segmentKvp.Value;
for (int i = 0; i < segment.Points.Length; i++)
{
segment.Points[i] = pointMap[segment.Points[i]];
}
segmentMap.Add(segmentKvp.Key, AddSegment(segment));
}
}
}
List <int> newConstraints = default;
if (constraints != null)
{
SaveUndo(ElementType.Constraint);
changedTypes |= ElementType.Constraint;
SaveUndo(ElementType.Point);
changedTypes |= ElementType.Point;
newConstraints = new List <int>();
foreach (var constraint in constraints)
{
if ((pointMap != null) && (constraint.Points != null))
{
for (int i = 0; i < constraint.Points.Length; i++)
{
constraint.Points[i] = pointMap[constraint.Points[i]];
}
}
if ((segmentMap != null) && (constraint.Segments != null))
{
for (int i = 0; i < constraint.Segments.Length; i++)
{
constraint.Segments[i] = segmentMap[constraint.Segments[i]];
}
}
newConstraints.Add(AddConstraint(constraint));
}
}
if (changedTypes != 0)
{
OnElementsChanged(changedTypes);
}
Invalidate();
return(pointMap, segmentMap, newConstraints);
}
//--------------------------------------------------------------------------------------------------
internal void OnSketchChanged(Sketch sketch, Sketch.ElementType types)
{
if (sketch == _SketchEditorTool.Sketch)
{
if (types.HasFlag(Sketch.ElementType.Point))
{
// Check for lost points
var lostPoints = PointElements.Where(pc => !sketch.Points.ContainsKey(pc.PointIndex)).ToArray();
foreach (var lostPoint in lostPoints)
{
lostPoint.Remove();
PointElements.Remove(lostPoint);
}
}
if (types.HasFlag(Sketch.ElementType.Segment))
{
// Check for lost segments
var lostSegs = SegmentElements.Where(sc => !sketch.Segments.ContainsValue(sc.Segment)).ToArray();
foreach (var lostSeg in lostSegs)
{
lostSeg.Remove();
SegmentElements.Remove(lostSeg);
}
}
if (types.HasFlag(Sketch.ElementType.Constraint))
{
// Check for lost constraints
var lostCons = ConstraintElements.Where(cc => !sketch.Constraints.Contains(cc.Constraint)).ToArray();
foreach (var lostCon in lostCons)
{
lostCon.Remove();
ConstraintElements.Remove(lostCon);
}
}
// Check for new ones
if (types.HasFlag(Sketch.ElementType.Point))
{
// Check for new points
var newPoints = sketch.Points.Where(kvp => !PointElements.Exists(pc => pc.PointIndex == kvp.Key));
foreach (var pointKvp in newPoints)
{
var element = new SketchEditorPointElement(_SketchEditorTool, pointKvp.Key, pointKvp.Value, _SketchEditorTool.Transform, sketch.Plane);
element.UpdateVisual();
element.Activate(true);
PointElements.Add(element);
}
}
if (types.HasFlag(Sketch.ElementType.Segment))
{
// Check for new segments
var newSegs = sketch.Segments.Where(seg => !SegmentElements.Exists(sc => sc.Segment == seg.Value));
foreach (var segmentKvp in newSegs)
{
var element = new SketchEditorSegmentElement(_SketchEditorTool, segmentKvp.Key, segmentKvp.Value, _SketchEditorTool.Transform, sketch.Plane);
element.OnPointsChanged(sketch.Points, sketch.Segments, _MarkerCounts);
element.UpdateVisual();
element.Activate(true);
SegmentElements.Add(element);
}
}
if (types.HasFlag(Sketch.ElementType.Constraint))
{
// Check for new constraints
var newCons = sketch.Constraints.Where(con => !ConstraintElements.Exists(cc => cc.Constraint == con));
foreach (var sketchConstraint in newCons)
{
var element = new SketchEditorConstraintElement(_SketchEditorTool, sketchConstraint, _SketchEditorTool.Transform, sketch.Plane);
element.OnPointsChanged(sketch.Points, sketch.Segments, _MarkerCounts);
element.UpdateVisual();
element.Activate(true);
ConstraintElements.Add(element);
}
}
// Update elements
_UpdateElementList();
if (types.HasFlag(Sketch.ElementType.Point))
{
OnPointsChanged(sketch.Points, sketch.Segments);
}
_SketchEditorTool.WorkspaceController.Invalidate();
}
}
