void OnFeedBackChanged(IFeedBack sender)
{
BoundingCube ext = BoundingCube.EmptyBoundingCube;
for (int i = 0; i < repaintObjects.Count; i++)
{
ext.MinMax(repaintObjects[i].GetExtent());
}
for (int i = 0; i < paintAsSelected.Count; i++)
{
ext.MinMax(paintAsSelected[i].GetExtent(0.0));
}
for (int i = 0; i < paintAsTransparent.Count; i++)
{
ext.MinMax(paintAsTransparent[i].GetExtent(0.0));
}
if (frame != null)
{
foreach (IView vw in frame.AllViews)
{
if (!ext.IsEmpty && vw is IActionInputView)
{
(vw as IActionInputView).SetAdditionalExtent(ext);
(vw as IActionInputView).MakeEverythingTranparent(makeTransparent);
}
vw.InvalidateAll();
}
}
}
private void facOnMouseClick(bool up, GeoPoint MousePosition, IView View)
{
if (!up) // also beim Drücken, nicht beim Loslassen
{
// statt des umgebenden Kubus der Objekte ist es nun der definierter Punkt p
cube = BoundingCube.EmptyBoundingCube;
cube.MinMax(base.BasePoint); // der FixPunkt
cube.MinMax(MousePosition); // der Skalierungspunkt kommt dazu
startPoint = MousePosition; // den Runterdrückpunkt merken
// base.BasePoint = startPoint;
startPointInput.Fixed = true; // und sagen dass er existiert
if (dis)
{
fac1.Fixed = true;
fac2.Fixed = true;
fac3.Fixed = true;
}
else
{
fac.Fixed = true;
}
base.FeedBack.Add(feedBackLine);
base.SetFocus(endPointInput, true); // Focus auf den Endpunkt setzen
}
}
private void SetStartPoint(GeoPoint p)
{
// statt des umgebenden Rechtecks der Objekte ist es nun der definierter Punkt p
startPoint = p;
cube = BoundingCube.EmptyBoundingCube;
cube.MinMax(base.BasePoint); // der FixPunkt
cube.MinMax(p); // der Skalierungspunkt kommt hinzu
}
/// <summary>
/// Overrides <see cref="CADability.GeoObject.IGeoObjectImpl.GetBoundingCube ()"/>
/// </summary>
/// <returns></returns>
public override BoundingCube GetBoundingCube()
{
BoundingCube res = BoundingCube.EmptyBoundingCube;
res.MinMax(startPoint);
res.MinMax(endPoint);
return(res);
}
/// <summary>
/// Overrides <see cref="CADability.GeoObject.IGeoObjectImpl.GetBoundingCube ()"/>
/// </summary>
/// <returns></returns>
public override BoundingCube GetBoundingCube()
{
BoundingCube res = BoundingCube.EmptyBoundingCube;
res.MinMax(location);
return(res);
}
BoundingCube IOctTreeInsertable.GetExtent(double precision)
{
BoundingCube bc = new BoundingCube(start);
GeoPoint p = new GeoPoint();
if (dir.x > 0)
{
p.x = double.MaxValue;
}
else
{
p.x = double.MinValue;
}
if (dir.y > 0)
{
p.y = double.MaxValue;
}
else
{
p.y = double.MinValue;
}
if (dir.z > 0)
{
p.z = double.MaxValue;
}
else
{
p.z = double.MinValue;
}
bc.MinMax(p);
return(bc);
}
public BoundingCube GetExtent()
{
BoundingCube res = BoundingCube.EmptyBoundingCube;
foreach (IGeoObject go in list)
{
res.MinMax(go.GetBoundingCube());
}
return(res);
}
/// <summary>
/// Overrides <see cref="CADability.GeoObject.IGeoObjectImpl.GetBoundingCube ()"/>
/// </summary>
/// <returns></returns>
public override BoundingCube GetBoundingCube()
{
BoundingCube res = BoundingCube.EmptyBoundingCube;
// lock (this)
{
for (int i = 0; i < containedObjects.Count; ++i)
{
res.MinMax(containedObjects[i].GetBoundingCube());
}
}
return(res);
}
/// <summary>
/// Overrides <see cref="CADability.GeoObject.IGeoObjectImpl.GetExtent (double)"/>
/// </summary>
/// <param name="precision"></param>
/// <returns></returns>
public override BoundingCube GetExtent(double precision)
{
BoundingCube res = BoundingCube.EmptyBoundingCube;
if (compoundShape != null)
{
for (int i = 0; i < compoundShape.SimpleShapes.Length; ++i)
{
SimpleShape ss = compoundShape.SimpleShapes[i];
Border bdr = ss.Outline;
res.MinMax(bdr.AsPath().MakeGeoObject(plane).GetExtent(precision));
}
}
return(res);
}
BoundingCube IFeedBack.GetExtent()
{
GeoPoint[] pnts = new GeoPoint[4];
pnts[0] = pln.ToGlobal(new GeoPoint2D(-width / 2, -height / 2));
pnts[1] = pln.ToGlobal(new GeoPoint2D(width / 2, -height / 2));
pnts[2] = pln.ToGlobal(new GeoPoint2D(width / 2, height / 2));
pnts[3] = pln.ToGlobal(new GeoPoint2D(-width / 2, height / 2));
BoundingCube res = BoundingCube.EmptyBoundingCube;
for (int i = 0; i < 4; i++)
{
res.MinMax(pnts[i]);
}
return(res);
}
BoundingCube IOctTreeInsertable.GetExtent(double precision)
{
if (isOpen)
{
return(tangulation.octtree.Extend); // nicht endlich, also alles
}
if (extend.IsEmpty)
{
for (int i = 0; i < polygon.Count; i++)
{
extend.MinMax(plane.ToGlobal(polygon[i]));
}
}
return(extend);
}
public override void OnSetAction()
{
// base.ActiveObject = block;
base.TitleId = "MoveObjects";
copyObject = ConstrDefaults.DefaultCopyObjects;
feedBackLine = Line.Construct();
Color backColor = base.Frame.GetColorSetting("Colors.Feedback", Color.DarkGray);
feedBackLine.ColorDef = new ColorDef("", backColor);
base.SetCursor(SnapPointFinder.DidSnapModes.DidNotSnap, "Move");
vec = new GeoVectorInput("MoveObjects.Vector");
vec.SetGeoVectorEvent += new CADability.Actions.ConstructAction.GeoVectorInput.SetGeoVectorDelegate(Vec_OnSetGeoVector);
vec.MouseClickEvent += new MouseClickDelegate(VecOnMouseClick);
vec.CalculateGeoVectorEvent += new GeoVectorInput.CalculateGeoVectorDelegate(vecCalculateGeoVector);
vec.GetGeoVectorEvent += new GeoVectorInput.GetGeoVectorDelegate(vecGetGeoVector);
startPointInput = new GeoPointInput("Objects.StartPoint");
startPointInput.Optional = true;
startPointInput.SetGeoPointEvent += new CADability.Actions.ConstructAction.GeoPointInput.SetGeoPointDelegate(SetStartPoint);
startPointInput.GetGeoPointEvent += new CADability.Actions.ConstructAction.GeoPointInput.GetGeoPointDelegate(GetStartPoint);
endPointInput = new GeoPointInput("Objects.EndPoint");
endPointInput.Optional = true;
endPointInput.SetGeoPointEvent += new CADability.Actions.ConstructAction.GeoPointInput.SetGeoPointDelegate(SetEndPoint);
endPointInput.GetGeoPointEvent += new CADability.Actions.ConstructAction.GeoPointInput.GetGeoPointDelegate(GetEndPoint);
BooleanInput copy = new BooleanInput("Modify.CopyObjects", "YesNo.Values");
copy.DefaultBoolean = ConstrDefaults.DefaultCopyObjects;
copy.SetBooleanEvent += new CADability.Actions.ConstructAction.BooleanInput.SetBooleanDelegate(SetCopy);
base.SetInput(vec, startPointInput, endPointInput, copy);
BoundingCube result = BoundingCube.EmptyBoundingCube;
foreach (IGeoObject go in originals)
{
result.MinMax(go.GetBoundingCube());
}
GeoPoint blockCenter = result.GetCenter();
block.RefPoint = blockCenter;
vec.SetVectorFromPoint(blockCenter);
base.OnSetAction();
}
public override void OnSetAction()
{
base.ActiveObject = block;
base.TitleId = "ReflectObjects";
copyObject = ConstrDefaults.DefaultCopyObjects;
GeoPointInput reflectPoint = new GeoPointInput("ReflectObjects.Point");
// reflectPoint.GetGeoPointEvent += new GeoPointInput.GetGeoPointDelegate(GetReflectPoint);
reflectPoint.SetGeoPointEvent += new GeoPointInput.SetGeoPointDelegate(SetReflectPoint);
reflectPoint.Optional = true;
reflectLine = new CurveInput("ReflectObjects.Line");
reflectLine.Decomposed = true; // nur Einzelelemente, auch bei Polyline und Pfad
reflectLine.MouseOverCurvesEvent += new CurveInput.MouseOverCurvesDelegate(ReflectLine);
reflectLine.CurveSelectionChangedEvent += new CurveInput.CurveSelectionChangedDelegate(ReflectLineChanged);
PlaneInput reflectPlane = new PlaneInput("ReflectObjects.Plane");
reflectPlane.SetPlaneEvent += new PlaneInput.SetPlaneDelegate(SetReflectPlane);
// reflectPlane.GetPlaneEvent += new PlaneInput.GetPlaneDelegate(GetReflectPlane);
reflectPlane.Optional = true;
BooleanInput copy = new BooleanInput("Modify.CopyObjects", "YesNo.Values");
copy.DefaultBoolean = ConstrDefaults.DefaultCopyObjects;
copy.SetBooleanEvent += new CADability.Actions.ConstructAction.BooleanInput.SetBooleanDelegate(SetCopy);
base.SetInput(reflectPoint, reflectLine, reflectPlane, copy);
BoundingCube result = BoundingCube.EmptyBoundingCube;
foreach (IGeoObject go in originals)
{
result.MinMax(go.GetBoundingCube());
}
GeoPoint blockCenter = result.GetCenter();
block.RefPoint = blockCenter;
base.BasePoint = blockCenter;
reflectModOp = ModOp.ReflectPlane(new Plane(base.BasePoint, base.ActiveDrawingPlane.Normal, base.ActiveDrawingPlane.DirectionY));
reflectModOpStart = reflectModOp;
block.Modify(reflectModOp);
base.OnSetAction();
}
private List <MenuWithHandler> GetFacesSubmenus(Face face)
{
List <MenuWithHandler> res = new List <MenuWithHandler>();
if (face.IsFillet())
{
HashSet <Face> connectedFillets = new HashSet <Face>();
CollectConnectedFillets(face, connectedFillets);
FeatureCommandHandler fch = new FeatureCommandHandler(connectedFillets.ToArray(), this, "MenuId.Fillet");
MenuWithHandler fr = new MenuWithHandler("MenuId.Fillet.ChangeRadius");
fr.OnCommand = (menuId) =>
{
ParametricsRadius pr = new ParametricsRadius(connectedFillets.ToArray(), soa.Frame, true);
soa.Frame.SetAction(pr);
return(true);
};
fr.OnSelected = (mh, selected) =>
{
currentMenuSelection.Clear();
currentMenuSelection.AddRange(connectedFillets.ToArray());
currentView.Invalidate(PaintBuffer.DrawingAspect.Select, currentView.DisplayRectangle);
};
MenuWithHandler fd = new MenuWithHandler("MenuId.Fillet.Remove");
fd.OnCommand = (menuId) =>
{
Face[] involvedFaces = connectedFillets.ToArray();
Shell orgShell = involvedFaces[0].Owner as Shell;
if (orgShell != null)
{
RemoveFillet rf = new RemoveFillet(involvedFaces[0].Owner as Shell, new HashSet <Face>(involvedFaces));
Shell sh = rf.Result();
if (sh != null)
{
using (soa.Frame.Project.Undo.UndoFrame)
{
sh.CopyAttributes(orgShell);
IGeoObjectOwner owner = orgShell.Owner;
owner.Remove(orgShell);
owner.Add(sh);
}
}
}
soa.ResetMode();
return(true);
};
fd.OnSelected = (mh, selected) =>
{
currentMenuSelection.Clear();
currentMenuSelection.AddRange(connectedFillets.ToArray());
currentView.Invalidate(PaintBuffer.DrawingAspect.Select, currentView.DisplayRectangle);
};
fch.SubMenus = new MenuWithHandler[] { fr, fd };
res.Add(fch);
}
IEnumerable <Face> connected = face.GetSameSurfaceConnected();
// if (connected.Any())
{
List <Face> lconnected = new List <Face>(connected);
lconnected.Add(face);
BoundingCube ext = BoundingCube.EmptyBoundingCube;
foreach (Face fc in connected)
{
ext.MinMax(fc.GetExtent(0.0));
}
// maybe a full sphere, cone, cylinder or torus:
// except for the sphere: position axis
// except for the cone: change radius or diameter
// for the cone: smaller and larger diameter
// for cone and cylinder: total length
if (face.Surface is CylindricalSurface || face.Surface is CylindricalSurfaceNP || face.Surface is ToroidalSurface)
{
MenuWithHandler mh = new MenuWithHandler("MenuId.FeatureDiameter");
mh.OnCommand = (menuId) =>
{
ParametricsRadius pr = new ParametricsRadius(lconnected.ToArray(), soa.Frame, false);
soa.Frame.SetAction(pr);
return(true);
};
mh.OnSelected = (menuId, selected) =>
{
currentMenuSelection.Clear();
currentMenuSelection.AddRange(lconnected.ToArray());
currentView.Invalidate(PaintBuffer.DrawingAspect.Select, currentView.DisplayRectangle);
};
res.Add(mh);
}
if (face.Surface is CylindricalSurface || face.Surface is CylindricalSurfaceNP || face.Surface is ConicalSurface)
{
Line axis = null;
if (face.Surface is ICylinder cyl)
{
axis = cyl.Axis.Clip(ext);
}
if (face.Surface is ConicalSurface cone)
{
axis = cone.AxisLine(face.Domain.Bottom, face.Domain.Top);
}
MenuWithHandler mh = new MenuWithHandler("MenuId.AxisPosition");
mh.OnCommand = (menuId) =>
{
ParametricsDistanceActionOld pd = new ParametricsDistanceActionOld(lconnected, axis, soa.Frame);
soa.Frame.SetAction(pd);
return(true);
};
mh.OnSelected = (menuId, selected) =>
{
currentMenuSelection.Clear();
currentMenuSelection.AddRange(lconnected.ToArray());
currentView.Invalidate(PaintBuffer.DrawingAspect.Select, currentView.DisplayRectangle);
};
res.Add(mh);
}
}
if (face.Surface is PlaneSurface pls)
{
// try to find parallel outline edges to modify the distance
Edge[] outline = face.OutlineEdges;
for (int j = 0; j < outline.Length - 1; j++)
{
for (int k = j + 1; k < outline.Length; k++)
{
if (outline[j].Curve3D is Line l1 && outline[k].Curve3D is Line l2)
{
if (Precision.SameDirection(l1.StartDirection, l2.StartDirection, false))
{
// two parallel outline lines, we could parametrize the distance
Edge o1 = outline[j];
Edge o2 = outline[k]; // outline[i] is not captured correctly for the anonymous method. I don't know why. With local copies, it works.
double lmin = double.MaxValue;
double lmax = double.MinValue;
double p = Geometry.LinePar(l1.StartPoint, l1.EndPoint, l2.StartPoint);
lmin = Math.Min(lmin, p);
lmax = Math.Max(lmax, p);
p = Geometry.LinePar(l1.StartPoint, l1.EndPoint, l2.EndPoint);
lmin = Math.Max(Math.Min(lmin, p), 0);
lmax = Math.Min(Math.Max(lmax, p), 1);
GeoPoint p1 = Geometry.LinePos(l1.StartPoint, l1.EndPoint, (lmin + lmax) / 2.0);
GeoPoint p2 = Geometry.DropPL(p1, l2.StartPoint, l2.EndPoint);
if ((p1 | p2) > Precision.eps)
{
MenuWithHandler mh = new MenuWithHandler("MenuId.EdgeDistance");
Line feedback = Line.TwoPoints(p1, p2);
GeoObjectList feedbackArrow = currentView.Projection.MakeArrow(p1, p2, pls.Plane, Projection.ArrowMode.circleArrow);
mh.OnCommand = (menuId) =>
{
ParametricsDistanceActionOld pd = new ParametricsDistanceActionOld(o1, o2, feedback, pls.Plane, soa.Frame);
soa.Frame.SetAction(pd);
return(true);
};
mh.OnSelected = (m, selected) =>
{
currentMenuSelection.Clear();
currentMenuSelection.AddRange(feedbackArrow);
currentMenuSelection.Add(o1.OtherFace(face));
currentMenuSelection.Add(o2.OtherFace(face));
currentView.Invalidate(PaintBuffer.DrawingAspect.Select, currentView.DisplayRectangle);
};
res.Add(mh);
}
}
}
}
}
}
if (res.Count > 6)
{
List <MenuWithHandler> lm = new List <MenuWithHandler>();
for (int i = 4; i < res.Count; i++)
{
lm.Add(res[i]);
}
res.RemoveRange(4, lm.Count);
MenuWithHandler subMenu = new MenuWithHandler("MenuId.More");
subMenu.SubMenus = lm.ToArray();
res.Add(subMenu);
}
return(res);
}
public override void OnSetAction()
{
base.ActiveObject = block;
base.TitleId = "ScaleObjects";
dis = ConstrDefaults.DefaultScaleDistort;
copyObject = ConstrDefaults.DefaultCopyObjects;
feedBackLine = Line.Construct();
Color backColor = base.Frame.GetColorSetting("Colors.Feedback", Color.DarkGray);
feedBackLine.ColorDef = new ColorDef("", backColor);
base.SetCursor(SnapPointFinder.DidSnapModes.DidNotSnap, "Size");
clickandPress = false;
GeoPointInput fixPoint = new GeoPointInput("Objects.FixPoint", base.BasePoint);
fixPoint.Optional = true;
fixPoint.DefinesHotSpot = true;
fixPoint.HotSpotSource = "Hotspots.png:0";
fixPoint.SetGeoPointEvent += new CADability.Actions.ConstructAction.GeoPointInput.SetGeoPointDelegate(SetfixPoint);
fixPoint.GetGeoPointEvent += new CADability.Actions.ConstructAction.GeoPointInput.GetGeoPointDelegate(GetfixPoint);
// dieser Punkt mit dem Fixpunkt dient zur Faktor-Bestimmung, "1" läßt ihn unverändert, "2" verdoppelt seine Entfernung vom Fixpunkt
startPointInput = new GeoPointInput("Objects.StartPoint");
startPointInput.Optional = true;
startPointInput.SetGeoPointEvent += new CADability.Actions.ConstructAction.GeoPointInput.SetGeoPointDelegate(SetStartPoint);
startPointInput.GetGeoPointEvent += new CADability.Actions.ConstructAction.GeoPointInput.GetGeoPointDelegate(GetStartPoint);
endPointInput = new GeoPointInput("Objects.EndPoint");
endPointInput.Optional = true;
endPointInput.SetGeoPointEvent += new CADability.Actions.ConstructAction.GeoPointInput.SetGeoPointDelegate(SetEndPoint);
endPointInput.GetGeoPointEvent += new CADability.Actions.ConstructAction.GeoPointInput.GetGeoPointDelegate(GetEndPoint);
fac = new DoubleInput("ScaleObjects.Factor", faktor);
fac.ReadOnly = dis;
fac.Optional = dis;
fac.SetDoubleEvent += new CADability.Actions.ConstructAction.DoubleInput.SetDoubleDelegate(SetFactor);
fac.GetDoubleEvent += new CADability.Actions.ConstructAction.DoubleInput.GetDoubleDelegate(GetFactor);
fac.CalculateDoubleEvent += new CADability.Actions.ConstructAction.DoubleInput.CalculateDoubleDelegate(CalculateFactor);
fac.MouseClickEvent += new MouseClickDelegate(facOnMouseClick);
// Verzerrung
BooleanInput distort = new BooleanInput("ScaleObjects.Distort", "ScaleObjects.Distort.Values");
distort.DefaultBoolean = ConstrDefaults.DefaultScaleDistort;
distort.SetBooleanEvent += new CADability.Actions.ConstructAction.BooleanInput.SetBooleanDelegate(SetDistort);
fac1 = new DoubleInput("ScaleObjects.FactorX");
fac1.ReadOnly = !dis;
fac1.Optional = !dis;
fac1.SetDoubleEvent += new CADability.Actions.ConstructAction.DoubleInput.SetDoubleDelegate(SetFactor1);
fac1.GetDoubleEvent += new CADability.Actions.ConstructAction.DoubleInput.GetDoubleDelegate(GetFactor1);
fac1.CalculateDoubleEvent += new CADability.Actions.ConstructAction.DoubleInput.CalculateDoubleDelegate(CalculateFactor);
fac1.MouseClickEvent += new MouseClickDelegate(facOnMouseClick);
fac2 = new DoubleInput("ScaleObjects.FactorY");
fac2.ReadOnly = !dis;
fac2.Optional = !dis;
// fac2.Optional = true;
fac2.SetDoubleEvent += new CADability.Actions.ConstructAction.DoubleInput.SetDoubleDelegate(SetFactor2);
fac2.GetDoubleEvent += new CADability.Actions.ConstructAction.DoubleInput.GetDoubleDelegate(GetFactor2);
fac2.CalculateDoubleEvent += new CADability.Actions.ConstructAction.DoubleInput.CalculateDoubleDelegate(CalculateFactor2);
fac3 = new DoubleInput("ScaleObjects.FactorZ");
fac3.ReadOnly = !dis;
fac3.Optional = !dis;
// fac2.Optional = true;
fac3.SetDoubleEvent += new CADability.Actions.ConstructAction.DoubleInput.SetDoubleDelegate(SetFactor3);
fac3.GetDoubleEvent += new CADability.Actions.ConstructAction.DoubleInput.GetDoubleDelegate(GetFactor3);
fac3.CalculateDoubleEvent += new CADability.Actions.ConstructAction.DoubleInput.CalculateDoubleDelegate(CalculateFactor3);
BooleanInput copy = new BooleanInput("Modify.CopyObjects", "YesNo.Values");
copy.DefaultBoolean = ConstrDefaults.DefaultCopyObjects;
copy.SetBooleanEvent += new CADability.Actions.ConstructAction.BooleanInput.SetBooleanDelegate(SetCopy);
// erstmal wird das umgebende Rechteck bestimmt
cube = BoundingCube.EmptyBoundingCube;
foreach (IGeoObject go in originals)
{
cube.MinMax(go.GetBoundingCube());
}
GeoPoint blockCenter = cube.GetCenter();
block.RefPoint = blockCenter;
// im Basepoint steht der Fixpunkt der Skalierung
base.BasePoint = blockCenter;
base.SetInput(fixPoint, fac, startPointInput, endPointInput, distort, fac1, fac2, fac3, copy);
base.OnSetAction();
}
public override void OnSetAction()
{
// base.ActiveObject = block;
base.TitleId = "RotateObjects";
copyObject = ConstrDefaults.DefaultCopyObjects;
axisVector = base.ActiveDrawingPlane.Normal;
feedBackEllipse = Ellipse.Construct();
feedBackEllipse.SetEllipseCenterAxis(GeoPoint.Origin, GeoVector.XAxis, GeoVector.YAxis); // damit nicht alles 0
Color backColor = base.Frame.GetColorSetting("Colors.Feedback", Color.DarkGray);
feedBackEllipse.ColorDef = new ColorDef("", backColor);
base.FeedBack.Add(feedBackEllipse);
base.SetCursor(SnapPointFinder.DidSnapModes.DidNotSnap, "RotateSmall");
//--> diese Inputs werden gebraucht
GeoPointInput refPointInput = new GeoPointInput("Objects.RefPoint");
refPointInput.Optional = true;
refPointInput.SetGeoPointEvent += new CADability.Actions.ConstructAction.GeoPointInput.SetGeoPointDelegate(SetRefPoint);
refPointInput.GetGeoPointEvent += new CADability.Actions.ConstructAction.GeoPointInput.GetGeoPointDelegate(GetRefPoint);
refPointInput.DefinesHotSpot = true;
refPointInput.HotSpotSource = "Hotspots.png:0";
rotAngleInput = new AngleInput("RotateObjects.Angle");
rotAngleInput.SetAngleEvent += new CADability.Actions.ConstructAction.AngleInput.SetAngleDelegate(OnSetRotationAngle);
rotAngleInput.GetAngleEvent += new CADability.Actions.ConstructAction.AngleInput.GetAngleDelegate(OnGetRotationAngle);
rotAngleInput.CalculateAngleEvent += new CADability.Actions.ConstructAction.AngleInput.CalculateAngleDelegate(OnCalculateRotationAngle);
rotAngleInput.MouseClickEvent += new MouseClickDelegate(OnMouseClickRotationAngle);
startPointInput = new GeoPointInput("Objects.StartPoint");
startPointInput.Optional = true;
startPointInput.SetGeoPointEvent += new CADability.Actions.ConstructAction.GeoPointInput.SetGeoPointDelegate(OnSetStartPoint);
startPointInput.GetGeoPointEvent += new CADability.Actions.ConstructAction.GeoPointInput.GetGeoPointDelegate(OnGetStartPoint);
endPointInput = new GeoPointInput("Objects.EndPoint");
endPointInput.Optional = true;
endPointInput.SetGeoPointEvent += new CADability.Actions.ConstructAction.GeoPointInput.SetGeoPointDelegate(OnSetEndPoint);
endPointInput.GetGeoPointEvent += new CADability.Actions.ConstructAction.GeoPointInput.GetGeoPointDelegate(OnGetEndPoint);
rotateLineInput = new CurveInput("Constr.Rotate.AxisLine");
rotateLineInput.Decomposed = true; // nur Einzelelemente, auch bei Polyline und Pfad
rotateLineInput.MouseOverCurvesEvent += new CurveInput.MouseOverCurvesDelegate(RotateLine);
rotateLineInput.CurveSelectionChangedEvent += new CurveInput.CurveSelectionChangedDelegate(RotateLineChanged);
rotateLineInput.Optional = true;
srcPlane = new PlaneInput("Constr.Rotate.SourcePlane");
srcPlane.SetPlaneEvent += SrcPlane_OnSetPlane;
srcPlane.GetPlaneEvent += SrcPlane_OnGetPlane;
srcPlane.Optional = true;
trgPlane = new PlaneInput("Constr.Rotate.TargetPlane");
trgPlane.SetPlaneEvent += TrgPlane_OnSetPlane;
trgPlane.GetPlaneEvent += TrgPlane_OnGetPlane;
trgPlane.Optional = true;
offset = new MultipleChoiceInput("Constr.Rotate.Offset", "Constr.Rotate.Offset.Values");
offset.Optional = true;
offsetVal = 0;
offset.GetChoiceEvent += OnGetOffset;
offset.SetChoiceEvent += OnSetOffset;
BooleanInput copy = new BooleanInput("Modify.CopyObjects", "YesNo.Values");
copy.DefaultBoolean = ConstrDefaults.DefaultCopyObjects;
copy.SetBooleanEvent += new CADability.Actions.ConstructAction.BooleanInput.SetBooleanDelegate(SetCopy);
base.SetInput(refPointInput, rotAngleInput, startPointInput, endPointInput, rotateLineInput, srcPlane, trgPlane, offset, copy);
BoundingCube result = BoundingCube.EmptyBoundingCube;
foreach (IGeoObject go in originals)
{
result.MinMax(go.GetBoundingCube());
}
GeoPoint blockCenter = result.GetCenter();
block.RefPoint = blockCenter;
refPoint = blockCenter;
base.BasePoint = blockCenter; // für die Winkelberechnung
base.OnSetAction();
rotateLineInput.SetContextMenu("MenuId.Axis", this); // kann man erst hier machen, zuvor gibts die Property noch nicht
}
private double CalculateFactor(GeoPoint MousePosition)
{
if (!startPointInput.Fixed)
{
startPoint = MousePosition;
}
double divRBx; // Abstand rect-Rand zu Referenzpunt in x-Richtung
double divRBy; // Abstand rect-Rand zu Referenzpunt in y-Richtung
double divRBz; // Abstand rect-Rand zu Referenzpunt in z-Richtung
double divMBx; // Abstand MousePosition zu Referenzpunt in x-Richtung
double divMBy; // Abstand MousePosition zu Referenzpunt in y-Richtung
double divMBz; // Abstand MousePosition zu Referenzpunt in z-Richtung
BoundingCube cubeLoc = cube; // der umgebende Kubus der Objekte
cubeLoc.MinMax(base.BasePoint); // der Punkt kommt noch mit dazu, kann ja auch ausserhalb liegen
// es wird ein Faktor gebildet aus: (Abstand rect-Rand und Referenzpunkt) und (Abstand MousePos. und Referenzpunkt),
// getrennt für alle vier Quadranten
if (MousePosition.x > base.BasePoint.x)
{
divRBx = cubeLoc.Xmax - base.BasePoint.x;
divMBx = MousePosition.x - base.BasePoint.x;
}
else
{
divRBx = base.BasePoint.x - cubeLoc.Xmin;
divMBx = base.BasePoint.x - MousePosition.x;
}
if (MousePosition.y > base.BasePoint.y)
{
divRBy = cubeLoc.Ymax - base.BasePoint.y;
divMBy = MousePosition.y - base.BasePoint.y;
}
else
{
divRBy = base.BasePoint.y - cubeLoc.Ymin;
divMBy = base.BasePoint.y - MousePosition.y;
}
if (MousePosition.z > base.BasePoint.z)
{
divRBz = cubeLoc.Zmax - base.BasePoint.z;
divMBz = MousePosition.z - base.BasePoint.z;
}
else
{
divRBz = base.BasePoint.z - cubeLoc.Zmin;
divMBz = base.BasePoint.z - MousePosition.z;
}
// jetzt werden die drei Faktoren bestimmt
if (Math.Abs(divRBx) <= 1e-6)
{
faktorX = 0;
}
else
{
faktorX = divMBx / divRBx;
}
if (Math.Abs(divRBy) <= 1e-6)
{
faktorY = 0;
}
else
{
faktorY = divMBy / divRBy;
}
if (Math.Abs(divRBz) <= 1e-6)
{
faktorZ = 0;
}
else
{
faktorZ = divMBz / divRBz;
}
// falls einer ausfällt: den größten anderen nehmen, das erhöht den Benutzungskomfort
if (faktorX == 0)
{
faktorX = Math.Max(faktorY, faktorZ);
}
if (faktorY == 0)
{
faktorY = Math.Max(faktorX, faktorZ);
}
if (faktorZ == 0)
{
faktorZ = Math.Max(faktorX, faktorY);
}
if (dis)
{
return(faktorX); // falls Verzerrung: nur x-Wert, also: facWidth, facH ist global und wird in Setfaktor verwurstet
}
// if (divMBx == 0) return Math.Max(faktorY,faktorZ);
// if (divRBx == 0) return ;
// die Auswahl, welcher von beiden benutzt wird, Quadranten als Strahlen vom Referenzpunkt dirch die Ecken des umgebenden Rechtecks rectLoc
if ((divMBy / divMBx) > (divRBy / divRBx))
{
if ((divMBy / divMBz) > (divRBy / divRBz))
{
return(faktorZ);
}
else
{
return(faktorY);
}
}
else
{
if ((divMBx / divMBz) > (divRBx / divRBz))
{
return(faktorZ);
}
else
{
return(faktorX);
}
}
//BoundingRect rectLoc = rect;
//rectLoc.MinMax(base.ActiveDrawingPlane.Project(base.BasePoint)); // der Punkt kann ja auch ausserhalb liegen
//// es wird ein Faktor gebildet aus: (Abstand rect-Rand und Referenzpunkt) und (Abstand MousePos. und Referenzpunkt),
//// getrennt für alle vier Quadranten
//if (MousePosition.x > base.BasePoint.x)
//{
// divRBx = rectLoc.Right - base.BasePoint.x;
// divMBx = MousePosition.x - base.BasePoint.x;
//}
//else
//{
// divRBx = base.BasePoint.x - rectLoc.Left;
// divMBx = base.BasePoint.x - MousePosition.x;
//}
//if (MousePosition.y > base.BasePoint.y)
//{
// divRBy = rectLoc.Top - base.BasePoint.y;
// divMBy = MousePosition.y - base.BasePoint.y;
//}
//else
//{
// divRBy = base.BasePoint.y - rectLoc.Bottom;
// divMBy = base.BasePoint.y - MousePosition.y;
//}
//// jetzt werden die beiden Faktoren bestimmt
//if (divRBy == 0) facH = 0;
//else facH = divMBy / divRBy;
//if (divRBx == 0) facW = 0;
//else facW = divMBx / divRBx;
//if (dis) return facW; // falls Verzerrung: nur x-Wert, also: facWidth, facH ist global und wird in Setfaktor verwurstet
//// falls einer ausfällt: den anderen nehmen, das erhöht den Benutzungskomfort
//if (facH == 0) facH = facW;
//if (facW == 0) facW = facH;
//if (divMBx == 0) return facH;
//if (divRBx == 0) return facW;
//// die Auswahl, welcher von beiden benutzt wird, Quadranten als Strahlen vom Referenzpunkt dirch die Ecken des umgebenden Rechtecks rectLoc
//if ((divMBy / divMBx) > (divRBy / divRBx))
// return facH;
//else return facW;
}
