static public bool ruledSolidTest(GeoObjectList geoObjectList, Model model)
{ // Tested für SelectedObjectsAction, ob Eintrag enabled oder nicht
bool temp;
if ((geoObjectList.Count == 1) && (geoObjectList[0] is ICurve) && (findPath(geoObjectList[0], model, out temp) != null))
{ // ein Element, Pfad und geschlossen
return(true);
}
if ((geoObjectList.Count == 2) && (geoObjectList[0] is ICurve) && (geoObjectList[1] is ICurve))
{ // zwei Elemente, auf geschlossene Pfade testen
Path p1 = (findPath(geoObjectList[0], model, out temp));
Path p2 = (findPath(geoObjectList[1], model, out temp));
if ((p1 != null) && (p2 != null))
{
if ((p1.GetPlanarState() == PlanarState.Planar) && (p2.GetPlanarState() == PlanarState.Planar)) // jeder Pfad in sich in einer Ebene
{ // beide eben, jetzt nur noch: unterschiedliche Ebenen:
if (!Precision.IsEqual(p1.GetPlane(), p2.GetPlane()))
{
return(true);
}
}
}
}
return(false);
}
virtual public bool OnCommand(string MenuId)
{
switch (MenuId)
{
case "MenuId.Explode":
if (Frame.ActiveAction is SelectObjectsAction)
{
using (Frame.Project.Undo.UndoFrame)
{
IGeoObjectOwner addTo = dimension.Owner;
if (addTo == null)
{
addTo = Frame.ActiveView.Model;
}
GeoObjectList toSelect = dimension.Decompose();
addTo.Remove(dimension);
for (int i = 0; i < toSelect.Count; ++i)
{
addTo.Add(toSelect[i]);
}
SelectObjectsAction soa = Frame.ActiveAction as SelectObjectsAction;
soa.SetSelectedObjects(toSelect); // alle Teilobjekte markieren
}
}
return(true);
}
return(false);
}
public Constr3DRuledFace(GeoObjectList geoObjectList, IFrame frame)
{ // constructor für SelectedObjectsAction, ein selektierter Pfad
bool pathCreatedFromModel;
if (geoObjectList == null)
{
selectedMode = 0;
}
else
{
//if (geoObjectList.Count == 2)
// { ruledSolidDo(geoObjectList, frame); }
//else
selectedMode = 1;
p1 = findPath(geoObjectList[0], frame.ActiveView.Model, out pathCreatedFromModel);
if (p1 != null)
{
attrObject = geoObjectList[0]; // merker, um das passende Attribut zu bekommen
iGeoObjectOrg1 = geoObjectList[0]; // zum Weglöschen des Originals in onDone
owner1 = geoObjectList[0].Owner; // owner merken für löschen
if (pathCreatedFromModel)
{
iGeoObjectOrg1 = null; // zum nicht Weglöschen des Originals in onDone
pathCreatedFromModel1 = p1; // kopie merken für onDone
}
}
}
}
private void MakeBlock(int horLeft, int horRight, int verDown, int verUp, double distX, double distY)
{ // läuft asynchron
backgroundBlock = Block.Construct();
for (int i = -horLeft; i <= horRight; ++i)
{
if (i != 0) // i=0 ist das Original, soll nicht verdoppelt werden!
{
GeoObjectList li = new GeoObjectList();
// für jede Kopie ein Clone machen
li = originals.CloneObjects();
// AbstandX * Kopienwinkel:
GeoVector vect = (i * distX) * dirV;
ModOp m = ModOp.Translate(vect);
li.Modify(m);
backgroundBlock.Add(li);
}
for (int j = -verDown; j <= verUp; ++j)
{
if (j != 0) // J=0 ist das Original, soll nicht verdoppelt werden!
{
GeoObjectList liV = new GeoObjectList();
// für jede Kopie ein Clone machen
liV = originals.CloneObjects();
// der senkrechte Winkel auf Kopienwinkel dirV
GeoVector dirV_Vert = base.ActiveDrawingPlane.Normal ^ dirV;
GeoVector vectV = (i * distX) * dirV + (j * distY) * dirV_Vert;
ModOp m = ModOp.Translate(vectV);
liV.Modify(m);
backgroundBlock.Add(liV);
}
}
}
}
private bool showCirc()
{
block = Block.Construct();
for (int i = 1; i < copCount; ++i)
{
GeoObjectList li = new GeoObjectList();
// für jede Kopie ein Clone machen
li = originals.CloneObjects();
ModOp m = ModOp.Rotate(rotationPoint, base.ActiveDrawingPlane.Normal, i * copAngle);
if (!objRot) // Objekte drehen mit: einfach modifizieren
{
li.Modify(m);
}
else
{ // Objekte drehen nicht mit: Translation des gedrehten centerpoints
ModOp mt = ModOp.Translate(new GeoVector(centerPoint, m * centerPoint));
li.Modify(mt);
}
block.Add(li);
}
if (block.Count > 0)
{
base.ActiveObject = block;
return(true);
}
else
{
base.ActiveObject = null;
return(false);
}
}
static public void SpaceDown(GeoObjectList gl, Projection projection, Project pr)
{
using (pr.Undo.UndoFrame)
{
IGeoObject[] geoArray = new IGeoObject[gl.Count];
for (int i = 0; i < gl.Count; ++i) // umkopieren auf ein Array, um den Sort machen zu können
{
geoArray[i] = gl[i];
}
// hier nun Sort, der Compare steht oben als lokal class und braucht die Parameter: Sort nach y = false und pm
Array.Sort(geoArray, 0, geoArray.Length, new CompareGeoObject(false, projection));
// die Rechtecke des ersten und letzten Objeks für die Gesamtausdehnung
BoundingRect reStart = IGeoObjectImpl.GetExtent(geoArray[0], projection, false);
BoundingRect reEnd = IGeoObjectImpl.GetExtent(geoArray[geoArray.Length - 1], projection, false);
double reTotal = reEnd.Top - reStart.Bottom; // Gesamtausdehnung
double distRe = 0;
for (int i = 0; i < geoArray.Length; ++i) // Summe der Ausdehnung der Einzelnen:
{
BoundingRect re = IGeoObjectImpl.GetExtent(geoArray[i], projection, false);
distRe = distRe + re.Height;
}
double space = (reTotal - distRe) / (geoArray.Length - 1); // Gesamt - Summe Einzelne / Zwischenräume
double pos = reStart.Top;
for (int i = 1; i < geoArray.Length - 1; ++i) // vom zweiten bis zum vorletzten, die Äußeren bleiben unverändert
{
BoundingRect re = IGeoObjectImpl.GetExtent(geoArray[i], projection, false);
GeoVector2D trans2D = new GeoVector2D(0, pos + space - re.Bottom);
pos = pos + space + re.Height; // pos hochzählen auf den oberen Rand des aktuellen
GeoVector trans = projection.DrawingPlane.ToGlobal(trans2D);
ModOp m = ModOp.Translate(trans);
geoArray[i].Modify(m);
}
}
}
public override void OnDone()
{
// ist die Shift Taste gehalten, so werden Kopien gemacht, d.h. der die Elemente
// des blocks werden eingefügt. Ansonsten werden die original-Objekte verändert
// TODO: Feedback über Cursor bei Shift-Taste fehlt noch
// TODO: die neuen oder veränderten Objekte sollten markiert sein.
using (Frame.Project.Undo.UndoFrame)
{
ModOp m = ModOp.Translate(offset);
if (((Frame.UIService.ModifierKeys & Keys.Shift) != 0) || copyObject)
{
GeoObjectList cloned = new GeoObjectList();
foreach (IGeoObject go in originals)
{
IGeoObject cl = go.Clone();
cl.Modify(m);
// go.Owner.Add(cl);
cloned.Add(cl);
}
base.Frame.Project.GetActiveModel().Add(cloned);
}
else
{
originals.Modify(m);
}
}
base.ActiveObject = null; // damit es nicht gleich eingefügt wird
base.OnDone();
}
static public bool ruledFaceTest(GeoObjectList geoObjectList, Model model)
{ // Tested für SelectedObjectsAction, ob Eintrag enabled oder nicht
bool temp;
if ((geoObjectList.Count == 1) && (geoObjectList[0] is ICurve) && (findPath(geoObjectList[0], model, out temp) != null))
{ // ein Element, Pfad
return(true);
}
if ((geoObjectList.Count == 2) && (geoObjectList[0] is ICurve) && (geoObjectList[1] is ICurve))
{ // zwei Elemente, auf Pfade testen
Path p1 = (findPath(geoObjectList[0], model, out temp));
Path p2 = (findPath(geoObjectList[1], model, out temp));
if ((p1 != null) && (p2 != null))
{
if ((p1.IsClosed && p2.IsClosed) || (!p1.IsClosed && !p2.IsClosed)) // OPenCascade will nur geschlossene oder nur offene
{
if (((p1 as ICurve).GetPlanarState() == PlanarState.Planar) && ((p2 as ICurve).GetPlanarState() == PlanarState.Planar)) // jeder Pfad in sich in einer Ebene
{ // beide eben, jetzt nur noch: unterschiedliche Ebenen:
if (!Precision.IsEqual(p1.GetPlane(), p2.GetPlane()))
{
return(true);
}
}
if ((((p1 as ICurve).GetPlanarState() == PlanarState.Planar) || (p1 as ICurve).GetPlanarState() == PlanarState.UnderDetermined) && (((p2 as ICurve).GetPlanarState() == PlanarState.Planar) || (p2 as ICurve).GetPlanarState() == PlanarState.UnderDetermined)) // jeder Pfad in sich in einer Ebene
{ // beide eben, jetzt nur noch: unterschiedliche Ebenen:
return(true);
}
}
}
}
return(false);
}
public override void OnDone()
{
if (base.ActiveObject != null)
{
using (base.Frame.Project.Undo.UndoFrame)
{
CurrentMouseView.Canvas.Cursor = "WaitCursor";
GeoObjectList ToAdd = new GeoObjectList();
Model m = base.Frame.ActiveView.Model;
BRepOperation brepOp = new BRepOperation(toSplit.Shells[0], plane);
(Shell[] upper, Shell[] lower) = BRepOperation.SplitByPlane(toSplit.Shells[0], plane);
for (int i = 0; i < upper.Length; i++)
{
ToAdd.Add(Solid.MakeSolid(upper[i]));
}
for (int i = 0; i < lower.Length; i++)
{
ToAdd.Add(Solid.MakeSolid(lower[i]));
}
m.Remove(toSplit);
m.Add(ToAdd);
base.ActiveObject = null;
base.OnDone();
}
}
}
// Interface für MultiGeoPointInput mi
public void SetGeoPoint(int Index, GeoPoint ThePoint)
{
if (dimDir == DimDirection.Sloping) //Schrägbemassung
{
if (Index == 0)
{
base.BasePoint = ThePoint; // Referenzpunkt für die Richtungsbestimmung
}
if ((Index == 1) & (!dimDirInput.Fixed)) // nur, falls nicht explizit die Richtung bestimmt wurde
{ // Schrägbemassung: der zweite Punkt definiert mit dem 1. die Lage
dim.DimLineDirection = new GeoVector(dim.GetPoint(0), ThePoint);
}
}
// das folgende dient nur dazu, den Cursor umzuschalten, falls Bemassung getroffen ist
if (dim.PointCount == 2)
{
GeoObjectList li = base.GetObjectsUnderCursor(base.CurrentMousePoint);
for (int i = 0; i < li.Count; ++i)
{
if (li[i] is Dimension)
{
Dimension dimTemp = (li[i] as Dimension);
int ind;
Dimension.HitPosition hi = dimTemp.GetHitPosition(base.Frame.ActiveView.Projection, base.ProjectedPoint(CurrentMousePoint), out ind);
if ((hi & Dimension.HitPosition.DimLine) != 0)
{
base.Frame.ActiveView.SetCursor(CursorTable.GetCursor("Trim.cur"));
}
//TODO: Bemassungscursor!
}
}
}
dim.SetPoint(Index, ThePoint);
}
public ParametricsDistanceActionOld(Edge fromHere, Edge toHere, Line feedback, Plane plane, IFrame frame)
{
distanceFromHere = fromHere;
distanceToHere = toHere;
offsetStartPoint = feedback.StartPoint;
offsetFeedBack = frame.ActiveView.Projection.MakeArrow(feedback.StartPoint, feedback.EndPoint, plane, Projection.ArrowMode.circleArrow);
feedbackPlane = plane;
originalOffset = feedback.EndPoint - feedback.StartPoint;
shell = fromHere.PrimaryFace.Owner as Shell;
facesToMove = new List <Face>();
facesToKeep = new List <Face>();
if (toHere != null)
{
if (!toHere.PrimaryFace.Surface.IsExtruded(originalOffset))
{
facesToMove.Add(toHere.PrimaryFace);
}
if (!toHere.SecondaryFace.Surface.IsExtruded(originalOffset))
{
facesToMove.Add(toHere.SecondaryFace);
}
facesToMoveIsFixed = true;
}
if (fromHere != null)
{
if (!fromHere.PrimaryFace.Surface.IsExtruded(originalOffset))
{
facesToKeep.Add(fromHere.PrimaryFace);
}
if (!fromHere.SecondaryFace.Surface.IsExtruded(originalOffset))
{
facesToKeep.Add(fromHere.SecondaryFace);
}
}
}
private void SetDimLocation(GeoPoint p)
{ // der Lagepunkt der Bemassung
dim.DimLineRef = p;
if ((dimMethodPoint & !curveInput.Fixed) | (!dimMethodPoint & !dimPointInput.Fixed))
{
dim.SetPoint(0, new GeoPoint(p.x - base.WorldLength(15), p.y - base.WorldLength(15)));
}
base.ShowActiveObject = true;
// jetzt erfogt der Test, ob eine andere Bemassung vom Typ DimLocation getroffen wurde
dimAddTo = null; // dient als merker für DimLocationOnMouseClick, Methode s.u.
// Testen, ob eine Bemassung getroffen wurde
GeoObjectList li = base.GetObjectsUnderCursor(base.CurrentMousePoint);
for (int i = 0; i < li.Count; ++i)
{
if (li[i] is Dimension)
{ // die getroffene Bem. nutzen
Dimension dimTemp = (li[i] as Dimension);
if (dimTemp.DimType == Dimension.EDimType.DimLocation)
{ // nur Bemassung gleichen Typs
int ind; // wo getroffen? nur an Hilfslinie, nicht am Text
Dimension.HitPosition hi = dimTemp.GetHitPosition(base.Frame.ActiveView.Projection, base.ProjectedPoint(CurrentMousePoint), out ind);
if ((hi & Dimension.HitPosition.DimLine) != 0)
{ // jetzt also: Bemassung merken
dimAddTo = dimTemp;
// und zur Kennung optisch den Refpunkt setzen
dim.DimLineRef = dimTemp.DimLineRef;
}
}
}
}
PerpFoot();
}
private void initNurbsSurface()
{
// die NurbsSurface brauchen wir hier für die Ableitungen. Die sind nur schwer aus der Kurvendefinition herauszukriegen
// Hier also erstmal mit NURBS. Besser wäre es, aus der eigentlichen Definition, da muss man aber Gehirnschmalz reinstecken
// die NURBS Fläche läuft von 0 bis 1, also synchron zu PointAt. PointAt ist aber genauer
GeoPoint[,] pnts = new CADability.GeoPoint[8, 8];
double[] uknots = new double[pnts.GetLength(0)];
double[] vknots = new double[pnts.GetLength(1)];
for (int i = 0; i < uknots.Length; i++)
{
uknots[i] = (double)i / (uknots.Length - 1);
}
for (int i = 0; i < vknots.Length; i++)
{
vknots[i] = (double)i / (vknots.Length - 1);
}
for (int i = 0; i < pnts.GetLength(0); i++)
{
for (int j = 0; j < pnts.GetLength(1); j++)
{
pnts[i, j] = PointAt(new GeoPoint2D(uknots[i], vknots[j]));
}
}
try
{
forDerivation = new NurbsSurface(pnts, 3, 3, uknots, vknots, false, false);
forDerivation.ScaleKnots(0, 1, 0, 1);
#if DEBUG
GeoObjectList dbg = forDerivation.DebugGrid;
#endif
}
catch (NurbsException) { }
}
/// <summary>
/// Add all objects from l, which are or contain curves. The curves are projected onto the provided plane.
/// If l contains composite objects (e.g. Block, Path) the objects are decomposed.
/// </summary>
/// <param name="l"></param>
/// <param name="pln"></param>
public void Add(GeoObjectList l, Plane pln)
{
for (int i = 0; i < l.Count; i++)
{
AddPrimitiv(l[i], pln);
}
}
static public GeoObjectList AssertColor(GeoObjectList list)
{
foreach (IGeoObject go in list)
{
if (go is IColorDef cd && cd.ColorDef == null)
{
if (go is GeoObject.Point)
{
cd.ColorDef = PointColor;
}
if (go is ICurve)
{
cd.ColorDef = CurveColor;
}
if (go is Face)
{
cd.ColorDef = FaceColor;
}
if (go is Shell)
{
cd.ColorDef = FaceColor;
}
if (go is Solid)
{
cd.ColorDef = FaceColor;
}
}
}
return(list);
}
protected override bool FindTangentialPoint(MouseEventArgs e, IView vw, out GeoPoint found)
{
double mindist = double.MaxValue;
found = GeoPoint.Origin;
if (base.CurrentInput == lengthInput && iCurve is Line)
{
GeoObjectList l = base.GetObjectsUnderCursor(e.Location);
l.DecomposeAll();
for (int i = 0; i < l.Count; i++)
{
if (l[i] is ICurve)
{
double[] tanpos = (l[i] as ICurve).TangentPosition(iCurve.StartDirection);
if (tanpos != null)
{
for (int j = 0; j < tanpos.Length; j++)
{
GeoPoint p = (l[i] as ICurve).PointAt(tanpos[j]);
double d = base.WorldPoint(e.Location) | p;
if (d < mindist)
{
mindist = d;
found = p;
}
}
}
}
}
}
return(mindist != double.MaxValue);
}
public override void OnDone()
{
if (base.ActiveObject != null)
{
using (base.Frame.Project.Undo.UndoFrame)
{
Frame.ActiveView.Canvas.Cursor = "WaitCursor";
GeoObjectList ToAdd = new GeoObjectList();
Model m = base.Frame.ActiveView.Model;
PlaneSurface pls = new PlaneSurface(plane);
for (int i = 0; i < m.Count; ++i) // durch das ganze Modell laufen
{
ICurve[] crvs = Intersect(m[i], pls);
if (crvs != null)
{
for (int k = 0; k < crvs.Length; k++)
{
IGeoObject go = crvs[k] as IGeoObject;
go.CopyAttributes(base.ActiveObject);
ToAdd.Add(go);
}
}
}
m.Add(ToAdd);
base.KeepAsLastStyle(ActiveObject);
base.ActiveObject = null;
base.OnDone();
}
}
}
private Constr3DPathExtrude()
{ // wird über ":this" von den beiden nächsten Constructoren aufgerufen, initialisiert die Listen
selectedObjectsList = new GeoObjectList();
geoObjectOrgList = new List <IGeoObject>();
shapeList = new List <IGeoObject>();
ownerList = new List <IGeoObjectOwner>();
pathCreatedFromModelList = new List <Path>();
}
protected override bool FindTangentialPoint(MouseEventArgs e, IView vw, out GeoPoint found)
{
double mindist = double.MaxValue;
found = GeoPoint.Origin;
if (CurrentInput == width && startPointInput.Fixed)
{
GeoObjectList l = base.GetObjectsUnderCursor(e.Location);
l.DecomposeAll();
for (int i = 0; i < l.Count; i++)
{
if (l[i] is ICurve)
{
double[] tanpos = (l[i] as ICurve).TangentPosition(line.ParallelogramSecondaryDirection);
if (tanpos != null)
{
for (int j = 0; j < tanpos.Length; j++)
{
GeoPoint p = (l[i] as ICurve).PointAt(tanpos[j]);
double d = base.WorldPoint(e.Location) | p;
if (d < mindist)
{
mindist = d;
found = p;
}
}
}
}
}
}
if (CurrentInput == height && startPointInput.Fixed)
{
GeoObjectList l = base.GetObjectsUnderCursor(e.Location);
l.DecomposeBlocks(true);
l.DecomposeBlockRefs();
for (int i = 0; i < l.Count; i++)
{
if (l[i] is ICurve)
{
double[] tanpos = (l[i] as ICurve).TangentPosition(line.StartDirection);
if (tanpos != null)
{
for (int j = 0; j < tanpos.Length; j++)
{
GeoPoint p = (l[i] as ICurve).PointAt(tanpos[j]);
double d = base.WorldPoint(e.Location) | p;
if (d < mindist)
{
mindist = d;
found = p;
}
}
}
}
}
}
return(mindist != double.MaxValue);
}
virtual public bool OnCommand(string MenuId)
{
switch (MenuId)
{
case "MenuId.Reverse":
polyline.Reverse();
return(true);
case "MenuId.CurveSplit":
Frame.SetAction(new ConstrSplitCurve(polyline));
return(true);
case "MenuId.Explode":
if (Frame.ActiveAction is SelectObjectsAction)
{
using (Frame.Project.Undo.UndoFrame)
{
IGeoObjectOwner addTo = polyline.Owner;
if (addTo == null)
{
addTo = Frame.ActiveView.Model;
}
GeoObjectList toSelect = polyline.Decompose();
addTo.Remove(polyline);
for (int i = 0; i < toSelect.Count; ++i)
{
addTo.Add(toSelect[i]);
}
SelectObjectsAction soa = Frame.ActiveAction as SelectObjectsAction;
soa.SetSelectedObjects(toSelect); // alle Teilobjekte markieren
}
}
return(true);
case "MenuId.Aequidist":
Frame.SetAction(new ConstructAequidist(polyline));
return(true);
case "MenuId.Path.Vertex.StartWithMe":
{
if (polyline.IsClosed)
{
GeoPointProperty gpp = Frame.ContextMenuSource as GeoPointProperty;
if (gpp != null)
{
if (gpp.UserData.ContainsData("Index"))
{
int index = (int)gpp.UserData.GetData("Index");
polyline.CyclicalPermutation(index);
}
}
}
}
return(true);
}
return(false);
}
//public static bool faceTestExtrude(GeoObjectList selectedObjects)
//{
// for (int i = 0; i < selectedObjects.Count; i++)
// { // nur eins muss passen
// if ((selectedObjects[i] is Face) || (selectedObjects[i] is Shell) || ((selectedObjects[i] is ICurve) && (selectedObjects[i] as ICurve).IsClosed)) return true;
// }
// return false;
//}
//private Constr3DMakeFace()
//{ // wird über ":this" von den beiden nächsten Constructoren aufgerufen, initialisiert die Listen
// selectedObjectsList = new GeoObjectList();
// geoObjectOrgList = new List<IGeoObject>();
// faceList = new List<IGeoObject>();
// ownerList = new List<IGeoObjectOwner>();
// pathCreatedFromModelList = new List<Path>();
//}
public Constr3DMakeFace()
// : this()
{
selectedObjectsList = new GeoObjectList();
geoObjectOrgList = new List <IGeoObject>();
faceList = new List <IGeoObject>();
ownerList = new List <IGeoObjectOwner>();
pathCreatedFromModelList = new List <Path>();
}
public ReflectObjects(GeoObjectList list)
{
block = Block.Construct();
foreach (IGeoObject go in list)
{
block.Add(go.Clone());
}
originals = new GeoObjectList(list); // originale merken
}
/// <summary>
/// Calculates intersection objects. The objects in the list toIntersect are
/// intersected with the plane intersectWith.
/// </summary>
/// <param name="toIntersect">list of objects to intersect</param>
/// <param name="intersectWith">plane to intersect with</param>
/// <returns>intersection objects</returns>
public static GeoObjectList Intersect(GeoObjectList toIntersect, Plane intersectWith)
{
// vorläufige Implementierung, muss mit der Opencascade Umstellung geändert werden
GeoObjectList res = new GeoObjectList();
for (int i = 0; i < toIntersect.Count; ++i)
{
}
return(res);
}
public Constr3DPathExtrude(GeoObjectList selectedObjectsList) : this()
{
selectedMode = (selectedObjectsList != null);
if (selectedMode)
{
this.selectedObjectsList = selectedObjectsList.Clone();
ListDefault(selectedObjectsList.Count); // setzt alle Listen auf gleiche Länge, Inhalte "null"
}
;
}
public MoveObjects(GeoObjectList list)
{
block = Block.Construct();
foreach (IGeoObject go in list)
{
block.Add(go.Clone());
}
originals = new GeoObjectList(list);
offset = new GeoVector(0.0, 0.0, 0.0);
}
private int offsetVal; // 0: 0°, 1: 90°, 2: 180°, 3: 270°(-90°)
public RotateObjects(GeoObjectList list)
{
block = Block.Construct();
originals = new GeoObjectList(list);
rotationAngle = new Angle(0.0);
for (int i = 0; i < originals.Count; ++i)
{
block.Add(originals[i].Clone());
}
}
virtual public bool OnCommand(string MenuId)
{
switch (MenuId)
{
case "MenuId.Explode":
if (Frame.ActiveAction is SelectObjectsAction)
{
SelectObjectsAction soa = Frame.ActiveAction as SelectObjectsAction;
soa.SetSelectedObjects(new GeoObjectList());
//Application.DoEvents();
using (Frame.Project.Undo.UndoFrame)
{
IGeoObjectOwner addTo = block.Owner;
if (addTo == null)
{
addTo = Frame.ActiveView.Model;
}
addTo.Remove(block);
GeoObjectList toSelect = block.Decompose();
for (int i = 0; i < toSelect.Count; i++)
{
addTo.Add(toSelect[i]);
}
soa.SetSelectedObjects(toSelect); // alle Teilobjekte markieren
}
}
return(true);
case "MenuId.SelectedObject.ToBackground":
if (ContextMenuSource != null)
{
block.MoveToBack(ContextMenuSource);
subEntries = null;
if (propertyPage != null)
{
propertyPage.Refresh(this);
}
}
return(true);
case "MenuId.SelectedObject.ToForeground":
if (ContextMenuSource != null)
{
block.MoveToFront(ContextMenuSource);
subEntries = null;
if (propertyPage != null)
{
propertyPage.Refresh(this);
}
}
return(true);
}
return(false);
}
public void InsertGeoPoint(int Index, GeoPoint ThePoint)
{
if (dim.PointCount >= 2)
{ // nach dem 2.Punkt ist keine Änderung der Methode mehr möglich!
dimMethod.ReadOnly = true;
// Testen, ob eine Bemassung getroffen wurde
GeoObjectList li = base.GetObjectsUnderCursor(base.CurrentMousePoint);
if (Settings.GlobalSettings.GetBoolValue("Dimension.AutoExtend", true)) // eingeführt am 30.08.2016
{
for (int i = 0; i < li.Count; ++i)
{
if (li[i] is Dimension)
{ // die getroffene Bem. nutzen
Dimension dimTemp = (li[i] as Dimension);
// nur wenn die Typen stimmen!
if ((dimTemp.DimType == Dimension.EDimType.DimPoints) | (dimTemp.DimType == Dimension.EDimType.DimCoord))
{
int ind; // wo getroffen?
Dimension.HitPosition hi = dimTemp.GetHitPosition(base.Frame.ActiveView.Projection, base.ProjectedPoint(CurrentMousePoint), out ind);
if ((hi & Dimension.HitPosition.DimLine) != 0)
{ // jetzt also: neuen Punkt einfügen, der kommt aus dim.
dimTemp.AddPoint(dim.GetPoint(0));
base.ActiveObject = null;
base.OnDone();
dimTemp.SortPoints();
dimTemp.Recalc();
return;
}
}
}
}
}
}
if ((dim.PointCount == 2) & (methodSelect == 0))
{ // ZweiPunktBemassung: Jetzt ist Schluss!
mi.Fixed = true;
if (!dimLocationInput.Fixed)
{
CADability.GeoObject.Point gPoint1 = ActionFeedBack.FeedbackPoint(base.Frame, PointSymbol.Cross);
gPoint1.Location = ThePoint;
base.FeedBack.Add(gPoint1);
base.SetFocus(dimLocationInput, true);
}
else
{
base.OnDone();
}
return;
}
dim.AddPoint(ThePoint);
CADability.GeoObject.Point gPoint = ActionFeedBack.FeedbackPoint(base.Frame, PointSymbol.Cross);
gPoint.Location = ThePoint;
base.FeedBack.Add(gPoint);
}
public void Add(GeoObjectList toAdd)
{
for (int i = 0; i < toAdd.Count; i++)
{
IGeoObject clone = toAdd[i].Clone();
IntegerProperty ip = new IntegerProperty(i, "Debug.Hint");
clone.UserData.Add("Debug", ip);
AssertColor(clone);
toShow.Add(clone);
}
}
private Block blk; // da werden die Objekte drinn gesammelt
public static bool pathTest(GeoObjectList selectedObjects)
{
for (int i = 0; i < selectedObjects.Count; i++)
{ // nur eins muss passen
if ((selectedObjects[i] is ICurve))
{
return(true);
}
}
return(false);
}
