public override void DrawInternal(
DrawContext.Wireframe context,
IWireframeGraphicsFactory2 graphicsFactory)
{
if (context.Config.TryDrawingTextAsText && graphicsFactory.SupportsText)
{
graphicsFactory.BeginGeometry((DxfEntity)this, context, context.GetPlotColor((DxfEntity)this), true, true, false, true);
graphicsFactory.CreateMText(this);
graphicsFactory.EndGeometry();
}
else
{
this.method_16((DrawContext)context, (IPathDrawer) new Class396((DxfEntity)this, context, graphicsFactory));
if (!context.Config.ShowTextAlignmentPoints)
{
return;
}
IList <Polyline4D> polylines = DxfUtil.smethod_36(this.method_18(), false, context.GetTransformer());
if (polylines.Count <= 0)
{
return;
}
Class940.smethod_3((DxfEntity)this, context, graphicsFactory, context.GetPlotColor((DxfEntity)this), true, false, true, polylines);
}
}
private IList <Polyline4D> method_14(
DrawContext context,
IClippingTransformer transformer)
{
bool closed = this.Closed;
List <Polyline3D> polyline3DList = new List <Polyline3D>();
if (this.Style.DisplayMiters)
{
int num1 = closed ? 0 : 1;
int num2 = closed ? this.list_0.Count : this.list_0.Count - 1;
for (int index = num1; index < num2; ++index)
{
DxfMLine.Segment segment = this.list_0[index];
if (segment.Elements.Count >= 2)
{
DxfMLine.Segment.Element element1 = segment.Elements[0];
DxfMLine.Segment.Element element2 = segment.Elements[segment.Elements.Count - 1];
if (element1.Parameters.Count > 0 && element2.Parameters.Count > 0)
{
Polyline3D polyline3D = new Polyline3D(2, false);
polyline3D.Add(segment.Position + element1.Parameters[0] * segment.MiterDirection);
polyline3D.Add(segment.Position + element2.Parameters[0] * segment.MiterDirection);
polyline3DList.Add(polyline3D);
}
}
}
}
return(DxfUtil.smethod_36((IList <Polyline3D>)polyline3DList, false, transformer));
}
private void GetPolylines4D(
DrawContext context,
IClippingTransformer transformer,
out bool fill,
out IList <Polyline4D> polylines4D)
{
DxfHeader header = context.Model.Header;
GraphicsConfig config = context.Config;
IList <WW.Math.Geometry.Polyline3D> polylines = (IList <WW.Math.Geometry.Polyline3D>) new List <WW.Math.Geometry.Polyline3D>();
fill = false;
if (header.ShowSplineControlPoints || config.ShowSplineControlPoints)
{
this.method_14(polylines);
}
if (config.ShowSplineApproximationPoints)
{
this.method_15(polylines);
}
if (!header.ShowSplineControlPoints || config.ShowSplineInterpolatedPoints)
{
int splineLineSegments = (int)context.Config.NoOfSplineLineSegments;
this.method_18(polylines, splineLineSegments, splineLineSegments);
}
IClippingTransformer transformer1 = (IClippingTransformer)transformer.Clone();
transformer1.SetPreTransform(this.Transform);
polylines4D = DxfUtil.smethod_36(polylines, false, transformer1);
}
private void GetPolylines4D(
DrawContext context,
IClippingTransformer transformer,
out IList <Polyline4D> polylines4D,
out IList <FlatShape4D> shapes)
{
IList <WW.Math.Geometry.Polyline3D> polylines;
this.GetPolylines(context, transformer.LineTypeScaler, out polylines, out shapes);
polylines4D = DxfUtil.smethod_36(polylines, false, transformer);
}
private IList <Polyline4D> GetPolylines4D(IClippingTransformer transformer)
{
WW.Math.Geometry.Polyline3D polyline3D = this.method_13();
List <WW.Math.Geometry.Polyline3D> polyline3DList = new List <WW.Math.Geometry.Polyline3D>(1);
polyline3DList.Add(polyline3D);
if (this.Thickness != 0.0)
{
DxfUtil.Extrude((IList <WW.Math.Geometry.Polyline3D>)polyline3DList, this.Thickness, this.ZAxis);
}
return(DxfUtil.smethod_36((IList <WW.Math.Geometry.Polyline3D>)polyline3DList, polyline3D.Closed, transformer));
}
private void GetPolylines4D(
IClippingTransformer transformer,
out IList <Polyline4D> polylines4D,
out bool fill)
{
IList <WW.Math.Geometry.Polyline3D> polylines = (IList <WW.Math.Geometry.Polyline3D>) new List <WW.Math.Geometry.Polyline3D>();
fill = false;
this.method_13(polylines);
DxfUtil.Transform(polylines, this.Transform);
polylines4D = DxfUtil.smethod_36(polylines, false, transformer);
}
public override void DrawInternal(
DrawContext.Wireframe context,
IWireframeGraphicsFactory graphicsFactory)
{
Polyline3DT imageBoundaryPolyline;
IClippingTransformer transformer;
IList <Polyline4D> polylines1 = this.method_16(context, out imageBoundaryPolyline, out transformer);
if (polylines1.Count <= 0)
{
return;
}
graphicsFactory.CreatePath((DxfEntity)this, context, context.Config.BackColor, false, polylines1, true, false);
IList <FlatShape4D> flatShape4DList = (IList <FlatShape4D>)null;
if (!context.WipeoutVariables.DisplayFrame)
{
return;
}
IList <WW.Math.Geometry.Polyline3D> polyline3DList;
if (context.Config.ApplyLineType)
{
IList <FlatShape4D> resultShapes = (IList <FlatShape4D>) new List <FlatShape4D>();
polyline3DList = (IList <WW.Math.Geometry.Polyline3D>) new List <WW.Math.Geometry.Polyline3D>();
Vector3D upward = Vector3D.CrossProduct(this.XAxis, this.YAxis);
if (upward == Vector3D.Zero)
{
upward = Vector3D.ZAxis;
}
else
{
upward.Normalize();
}
DxfUtil.smethod_11(context.Config, polyline3DList, resultShapes, imageBoundaryPolyline, this.GetLineType((DrawContext)context), upward, context.TotalLineTypeScale * this.LineTypeScale, context.GetTransformer().LineTypeScaler);
if (resultShapes.Count == 0)
{
flatShape4DList = (IList <FlatShape4D>)null;
}
}
else
{
polyline3DList = (IList <WW.Math.Geometry.Polyline3D>) new WW.Math.Geometry.Polyline3D[1]
{
imageBoundaryPolyline.ToPolyline3D()
};
flatShape4DList = (IList <FlatShape4D>)null;
}
IList <Polyline4D> polylines2 = DxfUtil.smethod_36(polyline3DList, false, transformer);
graphicsFactory.CreatePath((DxfEntity)this, context, this.GetColor((DrawContext)context), false, polylines2, false, true);
}
private void GetPolylines4D(
DrawContext context,
IClippingTransformer transformer,
out IList <Polyline4D> polylines4D,
out IList <IShape4D> shapes)
{
IList <Polyline3D> polylines;
IList <FlatShape4D> flatShapes;
this.GetPolylines(context, transformer.LineTypeScaler, out polylines, out flatShapes);
polylines4D = DxfUtil.smethod_36(polylines, false, transformer);
shapes = DxfUtil.smethod_37((ICollection <FlatShape4D>)flatShapes, transformer);
}
private void GetPolylines4D(
DrawContext context,
IClippingTransformer transformer,
out IList <Polyline4D> polylines4D,
out bool fill)
{
DxfHeader header = context.Model.Header;
GraphicsConfig config = context.Config;
IList <WW.Math.Geometry.Polyline3D> polylines = (IList <WW.Math.Geometry.Polyline3D>) new List <WW.Math.Geometry.Polyline3D>();
fill = false;
this.method_13(polylines);
DxfUtil.Transform(polylines, this.Transform);
polylines4D = DxfUtil.smethod_36(polylines, false, transformer);
}
private void GetPolylines4D(
DrawContext context,
IClippingTransformer transformer,
out IList <Polyline4D> polylines4D,
out IList <IShape4D> shapes)
{
IList <WW.Math.Geometry.Polyline3D> polylines;
IList <FlatShape4D> shapes1;
this.GetPolylines(context, transformer.LineTypeScaler, out polylines, out shapes1);
IClippingTransformer transformer1 = (IClippingTransformer)transformer.Clone();
transformer1.SetPreTransform(this.Transform);
polylines4D = DxfUtil.smethod_36(polylines, false, transformer1);
shapes = DxfUtil.smethod_37((ICollection <FlatShape4D>)shapes1, transformer1);
}
private void GetPolylines4D(
DrawContext context,
IClippingTransformer transformer,
double startAngle,
double endAngle,
out IList <Polyline4D> polylines4D,
out IList <FlatShape4D> shapes)
{
IList <WW.Math.Geometry.Polyline3D> polylines;
this.GetPolylines(context, transformer.LineTypeScaler, startAngle, endAngle, out polylines, out shapes);
if (this.Thickness != 0.0)
{
DxfUtil.Extrude(polylines, this.Thickness, this.ZAxis);
}
polylines4D = DxfUtil.smethod_36(polylines, false, transformer);
}
private void GetPolylines4D(
DrawContext context,
IClippingTransformer transformer,
out IList <Polyline4D> polylines4D,
out IList <FlatShape4D> shapes,
out bool fill)
{
IList <Polyline3D> polylines;
this.GetPolylines(context, transformer.LineTypeScaler, out polylines, out shapes, out fill);
fill = fill && this.ZAxis.X == 0.0 && this.ZAxis.Y == 0.0;
if (this.Thickness != 0.0)
{
DxfUtil.Extrude(polylines, this.Thickness, this.ZAxis);
}
polylines4D = DxfUtil.smethod_36(polylines, fill, transformer);
}
public override void DrawInternal(
DrawContext.Wireframe context,
IWireframeGraphicsFactory graphicsFactory)
{
IList <Polyline3D> polylines1;
IList <FlatShape4D> shapes;
this.method_14((DrawContext)context, context.GetTransformer().LineTypeScaler, out polylines1, out shapes);
IList <Polyline4D> polylines2 = DxfUtil.smethod_36(polylines1, false, context.GetTransformer());
if (polylines2.Count > 0)
{
graphicsFactory.CreatePath((DxfEntity)this, context, context.GetPlotColor((DxfEntity)this, this.dxfDimensionStyleOverrides_0.DimensionLineColor), false, polylines2, false, true);
}
if (shapes != null)
{
Class940.smethod_23((IPathDrawer) new ns0.Class0((DxfEntity)this, context, graphicsFactory), (IEnumerable <IShape4D>)shapes, this.dxfDimensionStyleOverrides_0.DimensionLineColor, context.GetLineWeight((DxfEntity)this));
}
if (!DxfLeader.smethod_7((ILeader)this, (IList <WW.Math.Point3D>) this.list_0))
{
return;
}
if (this.dxfDimensionStyleOverrides_0.LeaderArrowBlock == null)
{
Polyline3D polyline = this.method_15();
if (polyline == null)
{
return;
}
IClippingTransformer clippingTransformer = (IClippingTransformer)context.GetTransformer().Clone();
clippingTransformer.SetPreTransform(this.method_16());
List <Polyline4D> polyline4DList = new List <Polyline4D>((IEnumerable <Polyline4D>)clippingTransformer.Transform(polyline, polyline.Closed));
if (polyline4DList.Count <= 0)
{
return;
}
graphicsFactory.CreatePath((DxfEntity)this, context, context.GetPlotColor((DxfEntity)this, this.dxfDimensionStyleOverrides_0.DimensionLineColor), false, (IList <Polyline4D>)polyline4DList, true, true);
}
else
{
DxfInsert.Interface46 nterface46 = (DxfInsert.Interface46) new DxfInsert.Class1019((DxfEntity)this, context, graphicsFactory);
nterface46.imethod_0(0, 0, this.method_16());
nterface46.Draw(this.dxfDimensionStyleOverrides_0.LeaderArrowBlock, true);
}
}
public override void DrawInternal(
DrawContext.Wireframe context,
IWireframeGraphicsFactory2 graphicsFactory)
{
IClippingTransformer transformer = context.GetTransformer();
IList <WW.Math.Geometry.Polyline3D> polylines1;
IList <FlatShape4D> flatShapes;
this.method_13((DrawContext)context, transformer, out polylines1, out flatShapes);
IList <Polyline4D> polylines2 = DxfUtil.smethod_36(polylines1, false, transformer);
if (polylines2.Count > 0)
{
Class940.smethod_3((DxfEntity)this, context, graphicsFactory, context.GetPlotColor((DxfEntity)this), false, false, true, polylines2);
}
if (flatShapes == null)
{
return;
}
Class940.smethod_23((IPathDrawer) new Class396((DxfEntity)this, context, graphicsFactory), (IEnumerable <IShape4D>)flatShapes, this.Color.ToColor(), context.GetLineWeight((DxfEntity)this));
}
private IList <Polyline4D> GetPolylines4D(IClippingTransformer transformer)
{
return(DxfUtil.smethod_36(this.GetPolylines(), false, transformer));
}
private void GetPolylines4D(
DrawContext context,
IClippingTransformer transformer,
out IList <Polyline4D> polylines4D,
out IList <IShape4D> shapes)
{
IList <WW.Math.Geometry.Polyline3D> polyline3DList = (IList <WW.Math.Geometry.Polyline3D>) new List <WW.Math.Geometry.Polyline3D>(4);
IList <FlatShape4D> resultShapes = (IList <FlatShape4D>)null;
int count = this.list_0.Count;
if (count > 1)
{
bool flag = true;
if (this.FirstEdgeInvisible)
{
flag = false;
}
if (this.SecondEdgeInvisible)
{
flag = false;
}
if (count > 2)
{
if (this.ThirdEdgeInvisible)
{
flag = false;
}
if (count > 3 && this.FourthEdgeInvisible)
{
flag = false;
}
}
if (flag)
{
WW.Math.Geometry.Polyline3D polyline3D = new WW.Math.Geometry.Polyline3D(count, count > 2);
for (int index = 0; index < count; ++index)
{
polyline3D.Add(this.list_0[index]);
}
polyline3DList.Add(polyline3D);
}
else
{
if (!this.FirstEdgeInvisible)
{
polyline3DList.Add(new WW.Math.Geometry.Polyline3D(new WW.Math.Point3D[2]
{
this.list_0[0],
this.list_0[1]
}));
}
if (count > 2)
{
if (!this.SecondEdgeInvisible)
{
polyline3DList.Add(new WW.Math.Geometry.Polyline3D(new WW.Math.Point3D[2]
{
this.list_0[1],
this.list_0[2]
}));
}
if (this.Points.Count == 3)
{
if (!this.ThirdEdgeInvisible)
{
polyline3DList.Add(new WW.Math.Geometry.Polyline3D(new WW.Math.Point3D[2]
{
this.list_0[2],
this.list_0[0]
}));
}
}
else if (this.Points.Count == 4)
{
if (!this.ThirdEdgeInvisible)
{
polyline3DList.Add(new WW.Math.Geometry.Polyline3D(new WW.Math.Point3D[2]
{
this.list_0[2],
this.list_0[3]
}));
}
if (!this.FourthEdgeInvisible)
{
polyline3DList.Add(new WW.Math.Geometry.Polyline3D(new WW.Math.Point3D[2]
{
this.list_0[3],
this.list_0[0]
}));
}
}
}
}
IList <WW.Math.Geometry.Polyline3D> polylines = (IList <WW.Math.Geometry.Polyline3D>) new List <WW.Math.Geometry.Polyline3D>(4);
resultShapes = (IList <FlatShape4D>) new List <FlatShape4D>();
DxfUtil.smethod_2(context.Config, polyline3DList, resultShapes, polylines, this.GetLineType(context), Vector3D.ZAxis, context.TotalLineTypeScale * this.LineTypeScale, transformer.LineTypeScaler);
}
polylines4D = DxfUtil.smethod_36(polyline3DList, false, transformer);
shapes = DxfUtil.smethod_37((ICollection <FlatShape4D>)resultShapes, transformer);
}
private void GetPolylines4D(
DrawContext context,
int elementIndex,
int minElementCount,
DxfMLineStyle.Element styleElement,
IClippingTransformer transformer,
out IList <Polyline4D> polylines4D,
out IList <IShape4D> shapes)
{
WW.Math.Point3D point3D0 = this.point3D_0;
bool closed = this.Closed;
IList <Polyline3D> polyline3DList = (IList <Polyline3D>) new List <Polyline3D>();
IList <FlatShape4D> resultShapes = (IList <FlatShape4D>) new List <FlatShape4D>();
if (minElementCount == 0)
{
Polyline3D polyline3D = new Polyline3D(closed);
foreach (DxfMLine.Segment segment in this.list_0)
{
polyline3D.Add(segment.Position);
}
if (polyline3D.Count > 0)
{
DxfUtil.smethod_2(context.Config, polyline3DList, resultShapes, (IList <Polyline3D>) new Polyline3D[1]
{
polyline3D
}, styleElement.LineType, this.vector3D_0, 1.0, transformer.LineTypeScaler);
}
}
else
{
IList <Polyline3D> polylines = (IList <Polyline3D>) new List <Polyline3D>();
Polyline3D polyline3D = new Polyline3D();
bool flag = false;
foreach (DxfMLine.Segment segment in this.list_0)
{
WW.Math.Vector3D miterDirection = segment.MiterDirection;
WW.Math.Point3D position = segment.Position;
if (elementIndex < segment.Elements.Count)
{
DxfMLine.Segment.Element element = segment.Elements[elementIndex];
WW.Math.Point3D point3D1 = position;
if (element.Parameters.Count > 0)
{
WW.Math.Point3D point3D2 = point3D1 + miterDirection * element.Parameters[0];
if (element.Parameters.Count > 1)
{
for (int index = 1; index < element.Parameters.Count; index += 2)
{
WW.Math.Point3D point3D3 = point3D2 + segment.Direction * element.Parameters[index];
polyline3D.Add(point3D3);
if (index + 1 < element.Parameters.Count)
{
WW.Math.Point3D point3D4 = point3D2 + segment.Direction * element.Parameters[index + 1];
polyline3D.Add(point3D4);
polylines.Add(polyline3D);
polyline3D = new Polyline3D();
}
}
}
else if (polyline3D.Count > 0)
{
polyline3D.Add(point3D2);
polylines.Add(polyline3D);
polyline3D = new Polyline3D();
}
}
else if (element.AreaFillParameters.Count > 0)
{
flag = true;
}
}
}
DxfMLine.Segment segment1 = this.list_0[this.list_0.Count - 1];
if (closed && polyline3D.Count > 0)
{
DxfMLine.Segment segment2 = this.list_0[0];
if (elementIndex < segment2.Elements.Count)
{
DxfMLine.Segment.Element element = segment2.Elements[elementIndex];
WW.Math.Point3D position = segment2.Position;
if (element.Parameters.Count > 0)
{
WW.Math.Vector3D miterDirection = segment2.MiterDirection;
WW.Math.Point3D point3D = position + miterDirection * element.Parameters[0];
polyline3D.Add(point3D);
}
}
}
if (polyline3D.Count > 0)
{
polylines.Add(polyline3D);
}
if (flag)
{
polyline3DList.Add(polyline3D);
}
else if (polylines.Count > 0)
{
DxfUtil.smethod_2(context.Config, polyline3DList, resultShapes, polylines, styleElement.LineType, this.vector3D_0, 1.0, transformer.LineTypeScaler);
}
}
polylines4D = DxfUtil.smethod_36(polyline3DList, false, transformer);
shapes = DxfUtil.smethod_37((ICollection <FlatShape4D>)resultShapes, transformer);
}
private IList <Polyline4D> method_16(IClippingTransformer transformer)
{
WW.Math.Point3D point3D0 = this.point3D_0;
bool closed = this.Closed;
DxfMLine.Segment segment1 = this.list_0[0];
int num1 = int.MaxValue;
foreach (DxfMLine.Segment segment2 in this.list_0)
{
if (segment2.Elements.Count < num1)
{
num1 = segment2.Elements.Count;
}
}
IList <Polyline4D> polyline4DList;
if (num1 >= 2)
{
Polyline3D[] polyline3DArray = new Polyline3D[2];
for (int index = 0; index < polyline3DArray.Length; ++index)
{
polyline3DArray[index] = new Polyline3D(closed);
}
foreach (DxfMLine.Segment segment2 in this.list_0)
{
WW.Math.Vector3D miterDirection = segment2.MiterDirection;
WW.Math.Point3D position = segment2.Position;
if (segment2.Elements.Count == 0)
{
polyline3DArray[0].Add(position);
}
else
{
DxfMLine.Segment.Element element1 = (DxfMLine.Segment.Element)null;
DxfMLine.Segment.Element element2 = (DxfMLine.Segment.Element)null;
double num2 = double.MaxValue;
double num3 = double.MinValue;
for (int index = 0; index < num1; ++index)
{
DxfMLine.Segment.Element element3 = segment2.Elements[index];
if (element3.Parameters.Count != 0)
{
if (element1 == null)
{
element1 = element3;
num2 = element1.Parameters[0];
}
else if (element3.Parameters[0] < num2)
{
element1 = element3;
num2 = element1.Parameters[0];
}
if (element2 == null)
{
element2 = element3;
num3 = element2.Parameters[0];
}
else if (element3.Parameters[0] > num3)
{
element2 = element3;
num3 = element2.Parameters[0];
}
}
}
if (num2 == double.MaxValue)
{
num2 = 0.0;
}
if (num3 == double.MinValue)
{
num3 = 0.0;
}
if (element1 != null && element2 != null)
{
polyline3DArray[0].Add(position + miterDirection * num2);
polyline3DArray[1].Add(position + miterDirection * num3);
}
}
}
List <Polyline3D> polyline3DList;
if (closed)
{
polyline3DList = new List <Polyline3D>(2);
polyline3DList.AddRange((IEnumerable <Polyline3D>)polyline3DArray);
}
else
{
polyline3DList = new List <Polyline3D>(1);
Polyline3D polyline3D = new Polyline3D(polyline3DArray[0].Count + polyline3DArray[1].Count, true);
polyline3D.AddRange((IEnumerable <WW.Math.Point3D>)polyline3DArray[0]);
polyline3D.AddRange((IEnumerable <WW.Math.Point3D>)polyline3DArray[1].GetReverse());
polyline3DList.Add(polyline3D);
}
IClippingTransformer transformer1 = (IClippingTransformer)transformer.Clone();
transformer1.SetPreTransform(DxfUtil.GetToWCSTransform(this.vector3D_0));
polyline4DList = DxfUtil.smethod_36((IList <Polyline3D>)polyline3DList, false, transformer1);
}
else
{
polyline4DList = (IList <Polyline4D>)null;
}
return(polyline4DList);
}
