public GeneralLengthAction(LengthProperty lengthProperty, GeoPoint fixPoint, IGeoObject ignoreSnap) : this(lengthProperty, fixPoint)
{
if (ignoreSnap != null)
{
base.IgnoreForSnap = new GeoObjectList(ignoreSnap);
}
}
public ColorSelectionProperty(object go, string propertyName, string resourceId, ColorList clrTable, ColorList.StaticFlags flags)
{
useFlags = flags;
flags = clrTable.Usage;
clrTable.Usage = useFlags;
base.resourceId = resourceId;
colorList = clrTable;
choices = clrTable.Names;
objectWithProperty = go;
propertyInfo = objectWithProperty.GetType().GetProperty(propertyName);
MethodInfo mi = propertyInfo.GetGetMethod();
object[] prm = new object[0];
ColorDef selectedColor = (ColorDef)mi.Invoke(objectWithProperty, prm);
if (selectedColor != null)
{
selectedText = selectedColor.Name;
}
selectedCD = selectedColor;
clrTable.Usage = flags;
unselectedText = StringTable.GetString("ColorDef.Undefined");
toWatch = go as IGeoObject; // may be null
}
public void Init(System.Drawing.Point SourcePoint, Projection projection, SnapModes SnapMode, int MaxDist)
#endif
{
this.BestDist = double.MaxValue;
this.BestObject = null;
this.SnapPointIndex = 0;
SourceBeam = projection.PointBeam(SourcePoint);
this.SourcePoint = projection.ProjectionPlane.Intersect(SourceBeam);
this.Projection = projection;
this.SnapPoint = projection.DrawingPlanePoint(SourcePoint);
// MaxDist die die maximale Entfernung des Fangpunktes vom aktuellen Punkt bezogen auf die ProjectionPlane
#if WEBASSEMBLY
GeoPoint2D p1 = projection.ProjectionPlane.Intersect(projection.PointBeam(new CADability.WebDrawing.Point(SourcePoint.X, SourcePoint.Y + MaxDist)));
GeoPoint2D p2 = projection.ProjectionPlane.Intersect(projection.PointBeam(new CADability.WebDrawing.Point(SourcePoint.X + MaxDist, SourcePoint.Y)));
GeoPoint2D p3 = projection.ProjectionPlane.Intersect(projection.PointBeam(new CADability.WebDrawing.Point(SourcePoint.X, SourcePoint.Y - MaxDist)));
GeoPoint2D p4 = projection.ProjectionPlane.Intersect(projection.PointBeam(new CADability.WebDrawing.Point(SourcePoint.X - MaxDist, SourcePoint.Y)));
#else
GeoPoint2D p1 = projection.ProjectionPlane.Intersect(projection.PointBeam(new System.Drawing.Point(SourcePoint.X, SourcePoint.Y + MaxDist)));
GeoPoint2D p2 = projection.ProjectionPlane.Intersect(projection.PointBeam(new System.Drawing.Point(SourcePoint.X + MaxDist, SourcePoint.Y)));
GeoPoint2D p3 = projection.ProjectionPlane.Intersect(projection.PointBeam(new System.Drawing.Point(SourcePoint.X, SourcePoint.Y - MaxDist)));
GeoPoint2D p4 = projection.ProjectionPlane.Intersect(projection.PointBeam(new System.Drawing.Point(SourcePoint.X - MaxDist, SourcePoint.Y)));
#endif
this.MaxDist = Math.Max(Math.Max(p1 | this.SourcePoint, p2 | this.SourcePoint), Math.Max(p3 | this.SourcePoint, p4 | this.SourcePoint));
pickArea = projection.GetPickSpace(new Rectangle(SourcePoint.X - MaxDist, SourcePoint.Y - MaxDist, 2 * MaxDist, 2 * MaxDist));
this.BasePointValid = false;
this.SnapMode = SnapMode;
this.DidSnap = DidSnapModes.DidNotSnap;
faceDist = double.MaxValue;
}
/// <summary>
/// Use all active filters in this list to check whether an object is accepted or not.
/// If there is a <see cref="PreFilterEvent"/> the this event will be called.
/// </summary>
/// <param name="go">Object to check</param>
/// <returns>true: accepted, false: rejected</returns>
public bool Accept(IGeoObject go)
{
bool accepted = true;
bool doInternalFiltering = true;
if (PreFilterEvent != null)
{
PreFilterEvent(this, go, out accepted, out doInternalFiltering);
}
if (!accepted)
{
return(false);
}
if (!doInternalFiltering)
{
return(accepted);
}
foreach (DictionaryEntry de in entries)
{
Filter f = de.Value as Filter;
if (f.IsActive)
{
if (!f.Accept(go))
{
return(false);
}
}
}
return(true);
}
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();
}
ICurve ICurve.CloneModified(ModOp m)
{
IGeoObject clone = Clone();
clone.Modify(m);
return((ICurve)clone);
}
public override void OnDone()
{
if (base.ActiveObject != null)
{
using (base.Frame.Project.Undo.UndoFrame)
{
if (iCurveOrg != null) // evtl. Einzelobjekt (Polyline oder Path) als Original rauslöschen
{
owner.Remove(iCurveOrg as IGeoObject);
}
ICurve[] iCurveList = new ICurve[blk.Count]; // der Pfad braucht eine Kurvenliste
for (int i = 0; i < blk.Count; ++i)
{
iCurveList[i] = blk.Item(i) as ICurve; // von Block zu Liste
}
blk.Clear(); // weg mit dem Block, damit die Objekte nur einen owner haben
base.ActiveObject = null; // damit der onDone-Mechanismus nichts einfügt
if (Frame.GetBooleanSetting("Construct.MakePath", true))
{ // das Ergebnis soll in einem Pfad zusammengefasst werden!
Path path = Path.Construct();
path.Set(iCurveList); // macht den Path mit Header und so
path.CopyAttributes(iCurveSel as IGeoObject);
owner.Add(path); // nur zum owner des angeklickten Ursprungsobjekts
}
else
{
for (int i = 0; i < iCurveList.Length; ++i)
{
owner.Add(iCurveList[i] as IGeoObject); // nur zum owner des angeklickten Ursprungsobjekts
}
}
if (iCurveOrg == null) // die Einzelelemente des CreateFromModel identifizieren
//for (int i=0; i < iCurveList.Length; ++i)
//{
// IGeoObject obj = (iCurveList[i] as IGeoObject).UserData.GetData("CADability.Path.Original") as IGeoObject;
// if (obj!=null && obj.Owner!=null) obj.Owner.Remove(obj); // löschen
//}
{
for (int i = 0; i < pathCreatedFromModel.Count; ++i) // über den ursprünglichen Pfad laufen
{
IGeoObject obj = null;
if ((pathCreatedFromModel.Curve(i) as IGeoObject).UserData.ContainsData("CADability.Path.Original"))
{
obj = (pathCreatedFromModel.Curve(i) as IGeoObject).UserData.GetData("CADability.Path.Original") as IGeoObject;
}
if (obj != null && obj.Owner != null)
{
obj.Owner.Remove(obj); // löschen
}
(pathCreatedFromModel.Curve(i) as IGeoObject).UserData.RemoveUserData("CADability.Path.Original");
}
}
}
base.ActiveObject = null;
}
base.OnDone();
}
private void PaintFlatVisibleLayer(IPaintTo3D iPaintTo3D, IGeoObject go, Hashtable visibleLayers)
{
// beim Drucken dürfen keine Displaylisten verwendet werden, denn es geht auf ein Bitmap
// deshalb hier rekursiv runterbrechen, bis die Ebene klar ist und dann ohne Liste
// auf iPaintTo3D ausgeben.
if (go is Block)
{
Block blk = go as Block;
for (int i = 0; i < blk.Count; ++i)
{
PaintFlatVisibleLayer(iPaintTo3D, blk.Child(i), visibleLayers);
}
}
else if (go is BlockRef)
{
PaintFlatVisibleLayer(iPaintTo3D, (go as BlockRef).Flattened, visibleLayers);
}
else
{
if (go.Layer == null || visibleLayers.ContainsKey(go.Layer))
{
go.PaintTo3D(iPaintTo3D); // iPaintTo3D enthält die Information, dass keine Listen verwendet werden dürfen
}
}
}
static public IGeoObject AssertColor(IGeoObject go)
{
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(go);
}
private bool ruledFaceOrg()
{
if (!(Precision.IsEqual(p1.StartPoint, p2.StartPoint) && (Precision.IsEqual(p1.EndPoint, p2.EndPoint)))) // 1. Näherung, dass sie nicht gleich sind!
{
if ((p1.IsClosed && p2.IsClosed) || (!p1.IsClosed && !p2.IsClosed)) // OPenCascade will nur geschlossene oder nur offene
{
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))
{ // also nur Ebene Pfade mit unterschiedlichen Ebenen oder unbestimmt, z.B. Linien:
if (((p1 as ICurve).GetPlanarState() == PlanarState.Planar) && ((p2 as ICurve).GetPlanarState() == PlanarState.Planar) && Precision.IsEqual((p1 as ICurve).GetPlane(), (p2 as ICurve).GetPlane()))
{
return(false);
}
// also was geeignetes dabei
IGeoObject ss = Make3D.MakeRuledShell(p1, p2, Frame.Project);
if (ss != null)
{
if (base.ActiveObject != null)
{
ss.CopyAttributes(base.ActiveObject);
}
// der block wird das neue aktive Objekt, er muss die Attribute tragen, weil sie später
// wieder von ihm verlangt werden
// ss.CopyAttributes(attrObject);
base.ActiveObject = ss; // darstellen
base.ShowActiveObject = true;
return(true);
}
}
}
}
base.ShowActiveObject = false;
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);
}
}
}
bool OnMouseOverFace(ConstructAction.GeoObjectInput sender, IGeoObject[] TheGeoObjects, bool up)
{
bool ok = false;
for (int i = 0; i < TheGeoObjects.Length; ++i)
{
if (TheGeoObjects[i] is Face)
{
ok = true;
if (up)
{
theFace = (TheGeoObjects[i] as Face);
foreach (Edge edge in edges)
{
base.FeedBack.RemoveSelected(edge.Curve3D as IGeoObject);
}
edges.Clear();
edges.AddRange(theFace.AllEdges);
List <IGeoObject> geoObjects = new List <IGeoObject>();
foreach (Edge edge in edges)
{
IGeoObject go = edge.Curve3D as IGeoObject;
if (go != null)
{
base.FeedBack.AddSelected(go);
geoObjects.Add(go);
}
}
edgesInput.SetGeoObject(geoObjects.ToArray(), null);
firstClickClearsAll = true;
}
}
}
return(ok);
}
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
}
}
}
}
/// <summary>
/// Overrides <see cref="CADability.GeoObject.ISurfaceImpl.Make3dCurve (ICurve2D)"/>
/// </summary>
/// <param name="curve2d"></param>
/// <returns></returns>
public override ICurve Make3dCurve(CADability.Curve2D.ICurve2D curve2d)
{
if (curve2d is Curve2DAspect)
{
ICurve res = (curve2d as Curve2DAspect).Get3DCurve(this);
if (res != null)
{
return(res);
}
}
if (curve2d is ProjectedCurve pc)
{
if (pc.Surface is PlaneSurface)
{
BoundingRect otherBounds = new BoundingRect(PositionOf(pc.Surface.PointAt(pc.StartPoint)), PositionOf(pc.Surface.PointAt(pc.EndPoint)));
if (pc.Surface.SameGeometry(pc.GetExtent(), this, otherBounds, Precision.eps, out ModOp2D notneeded))
{
return(pc.Curve3DFromParams); // if trimmed or reversed still returns the correct 3d curve (but trimmed and/or reversed)
}
}
}
IGeoObject go = curve2d.MakeGeoObject(Plane.XYPlane);
go.Modify(fromUnitPlane);
return(go as ICurve);
}
private void OnDidChange(IGeoObject Sender, GeoObjectChange Change)
{
if (isChanging == 0)
{
FireDidChange(Change);
}
}
/// <summary>
/// Will be called when the state of an entry in the ControlCenter changes. this implementation must be called by a class overriding this method.
/// </summary>
/// <param name="sender">The ShowProperty that changed its state</param>
/// <param name="args">The new state</param>
protected void OnShowPropertyStateChanged(IPropertyEntry sender, StateChangedArgs args)
{
if (sender is IGeoObjectShowProperty)
{
if (args.EventState == StateChangedArgs.State.Selected)
{
focusedSelectedObject = (sender as IGeoObjectShowProperty).GetGeoObject();
if (FocusedObjectChangedEvent != null)
{
FocusedObjectChangedEvent(this, focusedSelectedObject);
}
}
else if (args.EventState == StateChangedArgs.State.UnSelected)
{
if (focusedSelectedObject == (sender as IGeoObjectShowProperty).GetGeoObject())
{
focusedSelectedObject = null;
}
if (FocusedObjectChangedEvent != null)
{
FocusedObjectChangedEvent(this, focusedSelectedObject);
}
}
else
{
return;
}
foreach (IView vw in base.Frame.AllViews)
{
vw.Invalidate(PaintBuffer.DrawingAspect.Select, vw.DisplayRectangle);
}
}
}
private bool Recalc()
{
if (theBaseCurve == null)
{
return(false);
}
Plane pln;
if (theBaseCurve.GetPlanarState() == PlanarState.Planar)
{
pln = theBaseCurve.GetPlane();
}
else
{
pln = base.ActiveDrawingPlane;
}
ICurve2D c2d = theBaseCurve.GetProjectedCurve(pln);
ICurve2D app = c2d.Approximate(false, Frame.GetDoubleSetting("Approximate.Precision", 0.01));
Border bdr = new Border(app);
Border[] res = bdr.GetParallel(theDistance, true, 0.0, theMinAngle);
Block blk = Block.Construct();
for (int i = 0; i < res.Length; ++i)
{
IGeoObject go = res[i].AsPath().MakeGeoObject(pln);
go.CopyAttributes(theBaseCurve as IGeoObject);
(go as IColorDef).ColorDef = (theBaseCurve as IColorDef).ColorDef;
blk.Add(go);
}
base.ActiveObject = blk;
return(true);
}
public int Compare(object x, object y)
{ // Typ-Casting
IGeoObject o1 = (IGeoObject)x;
IGeoObject o2 = (IGeoObject)y;
// Sortierung nach Mittelpunkten
BoundingRect re = IGeoObjectImpl.GetExtent(o1, projection, false);
GeoPoint2D p1 = re.GetCenter();
re = IGeoObjectImpl.GetExtent(o2, projection, false);
GeoPoint2D p2 = re.GetCenter();
if (dirx)
{
if (p1.x < p2.x)
{
return(-1);
}
if (p1.x > p2.x)
{
return(1);
}
}
else
{
if (p1.y < p2.y)
{
return(-1);
}
if (p1.y > p2.y)
{
return(1);
}
}
return(0);
}
private void OnGeoObjectDidChange(IGeoObject Sender, GeoObjectChange Change)
{
centerProperty.GeoPointChanged();
majorRadiusProperty.LengthChanged();
majorRadiusHotSpot[0].Position = ellipse.Center + 2.0 / 3.0 * ellipse.MajorAxis;
majorRadiusHotSpot[1].Position = ellipse.Center - 2.0 / 3.0 * ellipse.MajorAxis;
minorRadiusProperty.LengthChanged();
minorRadiusHotSpot[0].Position = ellipse.Center + 2.0 / 3.0 * ellipse.MinorAxis;
minorRadiusHotSpot[1].Position = ellipse.Center - 2.0 / 3.0 * ellipse.MinorAxis;
majorAxisProperty.GeoVectorChanged();
majorAxisHotSpot[0].Position = ellipse.Center + ellipse.MajorAxis;
majorAxisHotSpot[1].Position = ellipse.Center - ellipse.MajorAxis;
minorAxisProperty.GeoVectorChanged();
minorAxisHotSpot[0].Position = ellipse.Center + ellipse.MinorAxis;
minorAxisHotSpot[1].Position = ellipse.Center - ellipse.MinorAxis;
if (startAngleProperty != null)
{
startAngleProperty.AngleChanged();
startAngleHotSpot.Position = ellipse.StartPoint;
startPointProperty.Refresh();
if (endAngleProperty != null)
{
endAngleProperty.AngleChanged();
endAngleHotSpot.Position = ellipse.EndPoint;
endPointProperty.Refresh();
}
}
if (directionProperty != null)
{
directionProperty.Refresh();
}
}
/// <summary>
/// Adds a GeoObject to the list of displayed objects. In contrary to <see cref="Add"/> the object is displayed
/// in the select color and the select display mode.
/// </summary>
/// <param name="feedBackObject">Object to add</param>
/// <returns>the index in the list, may be used for <see cref="RemoveSelected(int)"/></returns>
public int AddSelected(IGeoObject feedBackObject)
{
paintAsSelected.Add(feedBackObject);
(feedBackObject as IFeedBack).FeedBackChangedEvent += new FeedBackChangedDelegate(OnFeedBackChanged);
OnFeedBackChanged(feedBackObject as IFeedBack);
return(paintAsSelected.Count - 1);
}
public virtual void Insert(int index, IGeoObject ToAdd)
{
using (new Changing(this, "Remove", ToAdd))
{
if (ToAdd.Owner != null)
{
ToAdd.Owner.Remove(ToAdd);
}
lock (this)
{
containedObjects.Insert(index, ToAdd);
}
ToAdd.WillChangeEvent += new ChangeDelegate(OnWillChange);
ToAdd.DidChangeEvent += new ChangeDelegate(OnDidChange);
ToAdd.Owner = this;
IColorDef cd = ToAdd as IColorDef;
if (cd != null && cd.ColorDef != null)
{
if (cd.ColorDef.Source == ColorDef.ColorSource.fromParent)
{
cd.ColorDef = CDfromParent;
}
}
}
}
private void AssertColor(IGeoObject go)
{
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;
}
}
}
private EntityObject GeoObjectToEntity(IGeoObject geoObject)
{
EntityObject entity = null;
switch (geoObject)
{
case GeoObject.Point point: entity = ExportPoint(point); break;
case GeoObject.Line line: entity = ExportLine(line); break;
case GeoObject.Ellipse elli: entity = ExportEllipse(elli); break;
case GeoObject.Polyline polyline: entity = ExportPolyline(polyline); break;
case GeoObject.BSpline bspline: entity = ExportBSpline(bspline); break;
case GeoObject.Path path: entity = ExportPath(path); break;
case GeoObject.Text text: entity = ExportText(text); break;
case GeoObject.Block block: entity = ExportBlock(block); break;
}
if (entity != null)
{
SetAttributes(entity, geoObject);
SetUserData(entity, geoObject);
}
return(entity);
}
public void Add(ICurve2D c2d)
{
IGeoObject go = c2d.MakeGeoObject(Plane.XYPlane);
AssertColor(go);
toShow.Add(go);
}
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();
}
}
}
void geoObjectInputFaceChanged(ConstructAction.GeoObjectInput sender, IGeoObject SelectedGeoObject)
{
selectedObjectsList.Clear();
base.FeedBack.ClearSelected();
selectedObjectsList.Add(SelectedGeoObject); // das eine in die Liste
ListDefault(1); // die Listen löschen und mit "1" vorbesetzen
makeFaceOrg();
}
public void Add(IGeoObject toAdd)
{
AssertColor(toAdd);
if (toAdd != null)
{
toShow.Add(toAdd);
}
}
/// <summary>
/// While the normal <see cref="HitTest(Projection.PickArea, bool)">HitTest</see> only checkes the <see cref="Location"/> of the object
/// this method checks the hittest of the object expanded according to the projection in this <paramref name="area"/>
/// </summary>
/// <param name="area">Pick area to check</param>
/// <param name="onlyInside">true, if the whole object must reside inside the pickarea, false if overlapping will suffice</param>
/// <returns>true when a hit is recognized</returns>
public bool RealHitTest(Projection.PickArea area, bool onlyInside)
{
ModOp m = ModOp.Translate(location.x, location.y, location.z) * ModOp.Scale(area.Projection.DeviceToWorldFactor);
IGeoObject clone = geoObject.Clone();
clone.Modify(m);
return(clone.HitTest(area, onlyInside));
}
public GeneralGeoPointAction(GeoPointProperty GeoPointProperty, IGeoObject ignoreSnap)
: this(GeoPointProperty)
{
if (ignoreSnap != null)
{
base.IgnoreForSnap = new GeoObjectList(ignoreSnap);
}
}
public GeneralGeoPointAction(GeoPoint initialGeoPointValue, IGeoObject ignoreSnap)
: this(initialGeoPointValue)
{
if (ignoreSnap != null)
{
base.IgnoreForSnap = new GeoObjectList(ignoreSnap);
}
}
