/// <inheritdoc />
public override void MoveGripPointsAt(
Entity entity, GripDataCollection grips, Vector3d offset, MoveGripPointsFlags bitFlags)
{
try
{
if (IsApplicable(entity))
{
foreach (var gripData in grips)
{
if (gripData is SecantNodalLeaderGrip levelMarkGrip)
{
var gripPoint = levelMarkGrip.GripPoint;
var secantNodalLeader = levelMarkGrip.SecantNodalLeader;
if (levelMarkGrip.GripName == GripName.InsertionPoint)
{
((BlockReference)entity).Position = gripPoint + offset;
secantNodalLeader.InsertionPoint = gripPoint + offset;
}
else if (levelMarkGrip.GripName == GripName.LeaderPoint)
{
secantNodalLeader.EndPoint = gripPoint + offset;
}
// Вот тут происходит перерисовка примитивов внутри блока
secantNodalLeader.UpdateEntities();
secantNodalLeader.BlockRecord.UpdateAnonymousBlocks();
}
else
{
base.MoveGripPointsAt(entity, grips, offset, bitFlags);
}
}
}
else
{
base.MoveGripPointsAt(entity, grips, offset, bitFlags);
}
}
catch (Exception exception)
{
if (exception.ErrorStatus != ErrorStatus.NotAllowedForThisProxy)
{
ExceptionBox.Show(exception);
}
}
}
/// <inheritdoc />
public override void MoveGripPointsAt(
Entity entity, GripDataCollection grips, Vector3d offset, MoveGripPointsFlags bitFlags)
{
try
{
if (IsApplicable(entity))
{
EntityUtils.LinearEntityGripPointMoveProcess(
entity, grips, offset, () => base.MoveGripPointsAt(entity, grips, offset, bitFlags));
}
else
{
base.MoveGripPointsAt(entity, grips, offset, bitFlags);
}
}
catch (Exception exception)
{
if (exception.ErrorStatus != ErrorStatus.NotAllowedForThisProxy)
{
ExceptionBox.Show(exception);
}
}
}
public override void MoveGripPointsAt(Entity entity, GripDataCollection grips,
Vector3d offset, MoveGripPointsFlags bitFlags)
{
var donut = entity as Circle;
if (donut != null)
{
var xdata = donut.GetXData(CommandClass.AppName);
if (xdata != null && xdata.Length > 0)
{
foreach (var grip in grips)
{
var outGrip = grip as DonutOutGripData;
if (outGrip != null)
{
donut.SetXData(CommandClass.AppName, 0,
new TypedValue((int)DxfCode.ExtendedDataReal,
(outGrip.GripPoint + offset - donut.Center).Length));
}
var inGrip = grip as DonutInGripData;
if (inGrip != null)
{
donut.Radius = (inGrip.GripPoint + offset - donut.Center).Length;
//donut.SetXData(CommandClass.AppName, 0,
// new TypedValue((int)DxfCode.ExtendedDataReal,
// (outGrip.GripPoint + offset - donut.Center).Length));
}
}
}
}
if (grips.OfType <DonutOutGripData>().Count() < grips.Count)
{
base.MoveGripPointsAt(entity, grips, offset, bitFlags);
}
}
//移动夹点
public override void MoveGripPointsAt(Entity entity, GripDataCollection grips, Vector3d offset, MoveGripPointsFlags bitFlags)
{
var ismove = false;
foreach (GripData gd in grips)
{
if (gd is UserGripData && ismove == false)
{
//UserGripData lagd = (UserGripData)gd;
if (entity is BlockReference)
{
var brf = entity as BlockReference;
brf.Position = brf.Position.Add(offset);
}
else if (entity is DBText)
{
var txt = entity as DBText;
txt.Position = txt.Position.Add(offset);
txt.AlignmentPoint = txt.AlignmentPoint.Add(offset);
}
else if (entity is MText)
{
var txt = entity as MText;
txt.Location = txt.Location.Add(offset);
}
ismove = true;
}
}
if (grips.Count > 0)
{
if (entity is BlockReference)
{
if (!ismove)
{
base.MoveGripPointsAt(entity, grips, offset, bitFlags);
}
mpt1 = pt1.Add(offset);
mpt2 = pt2.Add(offset);
pt = GeTools.MidPoint(mpt1, mpt2);
}
else if (entity is DBText)
{
if (!ismove)
{
base.MoveGripPointsAt(entity, grips, offset, bitFlags);
}
pt = ((DBText)entity).Position;
}
else if (entity is MText)
{
if (!ismove)
{
base.MoveGripPointsAt(entity, grips, offset, bitFlags);
}
pt = ((MText)entity).Location;
}
}
}
/// <inheritdoc />
public override void MoveGripPointsAt(
Entity entity, GripDataCollection grips, Vector3d offset, MoveGripPointsFlags bitFlags)
{
try
{
if (IsApplicable(entity))
{
foreach (var gripData in grips)
{
if (gripData is SectionVertexGrip vertexGrip)
{
var section = vertexGrip.Section;
if (vertexGrip.GripIndex == 0)
{
((BlockReference)entity).Position = vertexGrip.GripPoint + offset;
section.InsertionPoint = vertexGrip.GripPoint + offset;
}
else if (vertexGrip.GripIndex == section.MiddlePoints.Count + 1)
{
section.EndPoint = vertexGrip.GripPoint + offset;
}
else
{
section.MiddlePoints[vertexGrip.GripIndex - 1] =
vertexGrip.GripPoint + offset;
}
// Вот тут происходит перерисовка примитивов внутри блока
section.UpdateEntities();
section.BlockRecord.UpdateAnonymousBlocks();
}
else if (gripData is SectionTextGrip textGrip)
{
var section = textGrip.Section;
if (textGrip.Name == TextGripName.TopText)
{
var topStrokeVector = section.MiddlePoints.Any()
? (section.InsertionPoint - section.MiddlePoints.First()).GetNormal()
: (section.InsertionPoint - section.EndPoint).GetNormal();
var topShelfVector = topStrokeVector.GetPerpendicularVector().Negate();
var deltaY = topStrokeVector.DotProduct(offset) / section.BlockTransform.GetScale();
var deltaX = topShelfVector.DotProduct(offset) / section.BlockTransform.GetScale();
if (double.IsNaN(textGrip.CachedAlongTopShelfTextOffset))
{
section.AlongTopShelfTextOffset = deltaX;
}
else
{
section.AlongTopShelfTextOffset = textGrip.CachedAlongTopShelfTextOffset + deltaX;
}
if (double.IsNaN(textGrip.CachedAcrossTopShelfTextOffset))
{
section.AcrossTopShelfTextOffset = deltaY;
}
else
{
section.AcrossTopShelfTextOffset = textGrip.CachedAcrossTopShelfTextOffset + deltaY;
}
if (MainSettings.Instance.SectionDependentTextMovement)
{
if (double.IsNaN(textGrip.CachedAlongBottomShelfTextOffset))
{
section.AlongBottomShelfTextOffset = deltaX;
}
else
{
section.AlongBottomShelfTextOffset = textGrip.CachedAlongBottomShelfTextOffset + deltaX;
}
if (double.IsNaN(textGrip.CachedAcrossBottomShelfTextOffset))
{
section.AcrossBottomShelfTextOffset = deltaY;
}
else
{
section.AcrossBottomShelfTextOffset = textGrip.CachedAcrossBottomShelfTextOffset + deltaY;
}
}
}
if (textGrip.Name == TextGripName.BottomText)
{
var bottomStrokeVector = section.MiddlePoints.Any()
? (section.EndPoint - section.MiddlePoints.Last()).GetNormal()
: (section.EndPoint - section.InsertionPoint).GetNormal();
var bottomShelfVector = bottomStrokeVector.GetPerpendicularVector();
var deltaY = bottomStrokeVector.DotProduct(offset) / section.BlockTransform.GetScale();
var deltaX = bottomShelfVector.DotProduct(offset) / section.BlockTransform.GetScale();
if (double.IsNaN(textGrip.CachedAlongBottomShelfTextOffset))
{
section.AlongBottomShelfTextOffset = deltaX;
}
else
{
section.AlongBottomShelfTextOffset = textGrip.CachedAlongBottomShelfTextOffset + deltaX;
}
if (double.IsNaN(textGrip.CachedAcrossBottomShelfTextOffset))
{
section.AcrossBottomShelfTextOffset = deltaY;
}
else
{
section.AcrossBottomShelfTextOffset = textGrip.CachedAcrossBottomShelfTextOffset + deltaY;
}
if (MainSettings.Instance.SectionDependentTextMovement)
{
if (double.IsNaN(textGrip.CachedAlongTopShelfTextOffset))
{
section.AlongTopShelfTextOffset = deltaX;
}
else
{
section.AlongTopShelfTextOffset = textGrip.CachedAlongTopShelfTextOffset + deltaX;
}
if (double.IsNaN(textGrip.CachedAcrossTopShelfTextOffset))
{
section.AcrossTopShelfTextOffset = deltaY;
}
else
{
section.AcrossTopShelfTextOffset = textGrip.CachedAcrossTopShelfTextOffset + deltaY;
}
}
}
section.UpdateEntities();
section.BlockRecord.UpdateAnonymousBlocks();
}
else if (gripData is SectionAddVertexGrip addVertexGrip)
{
addVertexGrip.NewPoint = addVertexGrip.GripPoint + offset;
}
else
{
base.MoveGripPointsAt(entity, grips, offset, bitFlags);
}
}
}
else
{
base.MoveGripPointsAt(entity, grips, offset, bitFlags);
}
}
catch (Exception exception)
{
if (exception.ErrorStatus != ErrorStatus.NotAllowedForThisProxy)
{
ExceptionBox.Show(exception);
}
}
}
/// <inheritdoc />
public override void MoveGripPointsAt(
Entity entity, GripDataCollection grips, Vector3d offset, MoveGripPointsFlags bitFlags)
{
try
{
if (IsApplicable(entity))
{
foreach (var gripData in grips)
{
if (gripData is LevelMarkGrip levelMarkGrip)
{
var gripPoint = levelMarkGrip.GripPoint;
var levelMark = levelMarkGrip.LevelMark;
var scale = levelMark.GetFullScale();
var horV = (levelMark.EndPoint - levelMark.ObjectPoint).GetNormal();
if (levelMarkGrip.GripName == LevelMarkGripName.BasePoint)
{
((BlockReference)entity).Position = gripPoint + offset;
levelMark.InsertionPoint = gripPoint + offset;
}
else if (levelMarkGrip.GripName == LevelMarkGripName.ObjectPoint)
{
levelMark.ObjectPoint = gripPoint + offset;
levelMark.BottomShelfStartPoint = new Point3d(
levelMark.BottomShelfStartPoint.X,
levelMark.ObjectPoint.Y,
levelMark.BottomShelfStartPoint.Z);
levelMark.EndPoint = new Point3d(
levelMark.EndPoint.X,
levelMark.ObjectPoint.Y,
levelMark.EndPoint.Z);
}
else if (levelMarkGrip.GripName == LevelMarkGripName.BottomShelfStartPoint)
{
levelMark.BottomShelfStartPoint = gripPoint + offset;
if (levelMark.ObjectLine)
{
levelMark.ObjectPoint =
levelMark.BottomShelfStartPoint - (horV * levelMark.ObjectLineOffset * scale);
levelMark.EndPoint =
levelMark.BottomShelfStartPoint + (horV * _cachedBottomShelfLength);
}
else
{
levelMark.ObjectPoint = new Point3d(
levelMark.ObjectPoint.X,
levelMark.BottomShelfStartPoint.Y,
levelMark.ObjectPoint.Z);
levelMark.EndPoint =
levelMark.BottomShelfStartPoint + (horV * levelMark.BottomShelfLength * scale);
}
}
else if (levelMarkGrip.GripName == LevelMarkGripName.ArrowPoint)
{
levelMark.SetArrowPoint(gripPoint + offset);
}
else if (levelMarkGrip.GripName == LevelMarkGripName.TopShelfPoint)
{
levelMark.ShelfPoint = gripPoint + offset;
}
// Вот тут происходит перерисовка примитивов внутри блока
levelMark.UpdateEntities();
levelMark.BlockRecord.UpdateAnonymousBlocks();
}
else
{
base.MoveGripPointsAt(entity, grips, offset, bitFlags);
}
}
}
else
{
base.MoveGripPointsAt(entity, grips, offset, bitFlags);
}
}
catch (Exception exception)
{
if (exception.ErrorStatus != ErrorStatus.NotAllowedForThisProxy)
{
ExceptionBox.Show(exception);
}
}
}
/// <inheritdoc/>
public override void MoveGripPointsAt(
Entity entity, GripDataCollection grips, Vector3d offset, MoveGripPointsFlags bitFlags)
{
try
{
if (IsApplicable(entity))
{
// Проходим по коллекции ручек
foreach (var gripData in grips)
{
if (gripData is BreakLineGrip gripPoint)
{
var breakLine = gripPoint.BreakLine;
var scale = breakLine.GetFullScale();
// Далее, в зависимости от имени ручки произвожу действия
if (gripPoint.GripName == BreakLineGripName.StartGrip)
{
// Переношу точку вставки блока, и точку, описывающую первую точку в примитиве
// Все точки всегда совпадают (+ ручка)
var newPt = gripPoint.GripPoint + offset;
var length = breakLine.EndPoint.DistanceTo(newPt);
if (length < breakLine.MinDistanceBetweenPoints * scale)
{
/* Если новая точка получается на расстоянии меньше минимального, то
* переносим ее в направлении между двумя точками на минимальное расстояние
*/
var tmpInsertionPoint = ModPlus.Helpers.GeometryHelpers.Point3dAtDirection(
breakLine.EndPoint, newPt, breakLine.EndPoint,
breakLine.MinDistanceBetweenPoints * scale);
if (breakLine.EndPoint.Equals(newPt))
{
// Если точки совпали, то задаем минимальное значение
tmpInsertionPoint = new Point3d(
breakLine.EndPoint.X + (breakLine.MinDistanceBetweenPoints * scale),
breakLine.EndPoint.Y, breakLine.EndPoint.Z);
}
((BlockReference)entity).Position = tmpInsertionPoint;
breakLine.InsertionPoint = tmpInsertionPoint;
}
else
{
((BlockReference)entity).Position = gripPoint.GripPoint + offset;
breakLine.InsertionPoint = gripPoint.GripPoint + offset;
}
}
if (gripPoint.GripName == BreakLineGripName.MiddleGrip)
{
// Т.к. средняя точка нужна для переноса примитива, но не соответствует точки вставки блока
// и получается как средняя точка между InsertionPoint и EndPoint, то я переношу
// точку вставки
var lengthVector = (breakLine.InsertionPoint - breakLine.EndPoint) / 2;
((BlockReference)entity).Position = gripPoint.GripPoint + offset + lengthVector;
}
if (gripPoint.GripName == BreakLineGripName.EndGrip)
{
var newPt = gripPoint.GripPoint + offset;
if (newPt.Equals(((BlockReference)entity).Position))
{
breakLine.EndPoint = new Point3d(
((BlockReference)entity).Position.X + (breakLine.MinDistanceBetweenPoints * scale),
((BlockReference)entity).Position.Y, ((BlockReference)entity).Position.Z);
}
// С конечной точкой все просто
else
{
breakLine.EndPoint = gripPoint.GripPoint + offset;
}
}
// Вот тут происходит перерисовка примитивов внутри блока
breakLine.UpdateEntities();
breakLine.BlockRecord.UpdateAnonymousBlocks();
}
else
{
base.MoveGripPointsAt(entity, grips, offset, bitFlags);
}
}
}
else
{
base.MoveGripPointsAt(entity, grips, offset, bitFlags);
}
}
catch (Exception exception)
{
if (exception.ErrorStatus != ErrorStatus.NotAllowedForThisProxy)
{
ExceptionBox.Show(exception);
}
}
}
public void MoveGripPointsAtSubentityPaths(FullSubentityPath[] subPaths, IntPtr[] appData, Vector3d offset, MoveGripPointsFlags bitFlags)
{
createInstance();
BaseEntity.MoveGripPointsAtSubentityPaths(subPaths, appData, offset, bitFlags);
tr.Dispose();
}
public void MoveGripPointsAt(GripDataCollection grips, Vector3d offset, MoveGripPointsFlags bitFlags)
{
createInstance();
BaseEntity.MoveGripPointsAt(grips, offset,bitFlags);
tr.Dispose();
}
public override void MoveGripPointsAt(Entity entity, GripDataCollection grips, Vector3d offset, MoveGripPointsFlags bitFlags)
{
/*ArrowGripData gdata = new ArrowGripData();
* gdata.GripPoint = _getCustomGrip(entity);
* grips.Add(gdata);*/
base.MoveGripPointsAt(entity, grips, offset, bitFlags);
}
public void MoveGripPointsAtSubentityPaths(FullSubentityPath[] subPaths, IntPtr[] appData, Vector3d offset, MoveGripPointsFlags bitFlags)
{
createInstance();
BaseEntity.MoveGripPointsAtSubentityPaths(subPaths, appData, offset, bitFlags);
tr.Dispose();
}
public void MoveGripPointsAt(GripDataCollection grips, Vector3d offset, MoveGripPointsFlags bitFlags)
{
createInstance();
BaseEntity.MoveGripPointsAt(grips, offset, bitFlags);
tr.Dispose();
}
/// <inheritdoc />
public override void MoveGripPointsAt(
Entity entity, GripDataCollection grips, Vector3d offset, MoveGripPointsFlags bitFlags)
{
try
{
if (IsApplicable(entity))
{
foreach (var gripData in grips)
{
if (gripData is NodalLeaderGrip levelMarkGrip)
{
var gripPoint = levelMarkGrip.GripPoint;
var nodalLeader = levelMarkGrip.NodalLeader;
var scale = nodalLeader.GetFullScale();
if (levelMarkGrip.GripName == GripName.InsertionPoint)
{
((BlockReference)entity).Position = gripPoint + offset;
nodalLeader.InsertionPoint = gripPoint + offset;
nodalLeader.FramePoint = _initFramePoint + offset;
}
else if (levelMarkGrip.GripName == GripName.FramePoint)
{
if (nodalLeader.FrameType == FrameType.Rectangular)
{
var currentPosition = gripPoint + offset;
var frameHeight =
Math.Abs(currentPosition.Y - nodalLeader.InsertionPoint.Y) / scale;
var frameWidth = Math.Abs(currentPosition.X - nodalLeader.InsertionPoint.X) / scale;
if (!(frameHeight <= nodalLeader.MinDistanceBetweenPoints) &&
!(frameWidth <= nodalLeader.MinDistanceBetweenPoints))
{
nodalLeader.FramePoint = gripPoint + offset;
}
}
else
{
nodalLeader.FramePoint = gripPoint + offset;
}
}
else if (levelMarkGrip.GripName == GripName.LeaderPoint)
{
nodalLeader.EndPoint = gripPoint + offset;
}
// Вот тут происходит перерисовка примитивов внутри блока
nodalLeader.UpdateEntities();
nodalLeader.BlockRecord.UpdateAnonymousBlocks();
}
else
{
base.MoveGripPointsAt(entity, grips, offset, bitFlags);
}
}
}
else
{
base.MoveGripPointsAt(entity, grips, offset, bitFlags);
}
}
catch (Exception exception)
{
if (exception.ErrorStatus != ErrorStatus.NotAllowedForThisProxy)
{
ExceptionBox.Show(exception);
}
}
}
/// <inheritdoc />
public override void MoveGripPointsAt(
Entity entity, GripDataCollection grips, Vector3d offset, MoveGripPointsFlags bitFlags)
{
try
{
if (IsApplicable(entity))
{
// Проходим по коллекции ручек
foreach (var gripData in grips)
{
// Приводим ручку к моему классу
var gripPoint = gripData as AxisGrip;
// Проверяем, что это та ручка, что мне нужна.
if (gripPoint != null)
{
// Далее, в зависимости от имени ручки произвожу действия
var axis = gripPoint.Axis;
var scale = axis.GetFullScale();
if (gripPoint.GripName == AxisGripName.StartGrip)
{
// Переношу точку вставки блока, и точку, описывающую первую точку в примитиве
// Все точки всегда совпадают (+ ручка)
var newPt = gripPoint.GripPoint + offset;
var length = axis.EndPoint.DistanceTo(newPt);
if (length < axis.MinDistanceBetweenPoints * scale)
{
/* Если новая точка получается на расстоянии меньше минимального, то
* переносим ее в направлении между двумя точками на минимальное расстояние
*/
var tmpInsertionPoint = ModPlus.Helpers.GeometryHelpers.Point3dAtDirection(
axis.EndPoint, newPt, axis.EndPoint,
axis.MinDistanceBetweenPoints * scale);
if (axis.EndPoint.Equals(newPt))
{
// Если точки совпали, то задаем минимальное значение
tmpInsertionPoint = new Point3d(
axis.EndPoint.X,
axis.EndPoint.Y - (axis.MinDistanceBetweenPoints * scale),
axis.EndPoint.Z);
}
((BlockReference)entity).Position = tmpInsertionPoint;
axis.InsertionPoint = tmpInsertionPoint;
}
else
{
((BlockReference)entity).Position = gripPoint.GripPoint + offset;
axis.InsertionPoint = gripPoint.GripPoint + offset;
}
}
if (gripPoint.GripName == AxisGripName.MiddleGrip)
{
// Т.к. средняя точка нужна для переноса примитива, но не соответствует точки вставки блока
// и получается как средняя точка между InsertionPoint и EndPoint, то я переношу
// точку вставки
var lengthVector = (axis.InsertionPoint - axis.EndPoint) / 2;
((BlockReference)entity).Position = gripPoint.GripPoint + offset + lengthVector;
}
if (gripPoint.GripName == AxisGripName.EndGrip)
{
var newPt = gripPoint.GripPoint + offset;
Point3d newEndPoint;
if (newPt.Equals(((BlockReference)entity).Position))
{
newEndPoint = new Point3d(
((BlockReference)entity).Position.X,
((BlockReference)entity).Position.Y - (axis.MinDistanceBetweenPoints * scale),
((BlockReference)entity).Position.Z);
axis.EndPoint = newEndPoint;
}
else
{
axis.EndPoint = gripPoint.GripPoint + offset;
newEndPoint = gripPoint.GripPoint + offset;
}
// change bottom orient point
axis.BottomOrientPoint = GetSavePositionPoint(
_initInsertionPoint,
gripPoint.GripPoint,
newEndPoint,
_initBottomOrientPoint);
}
if (gripPoint.GripName == AxisGripName.BottomMarkerGrip)
{
var mainVector = axis.EndPoint - axis.InsertionPoint;
var v = mainVector.CrossProduct(Vector3d.ZAxis).GetNormal();
axis.BottomMarkerPoint = gripPoint.GripPoint + (offset.DotProduct(v) * v);
// Меняю также точку маркера-ориентира
if (_initBottomOrientPoint != Point3d.Origin)
{
axis.BottomOrientPoint = _initBottomOrientPoint + (offset.DotProduct(v) * v);
}
}
if (gripPoint.GripName == AxisGripName.TopMarkerGrip)
{
var mainVector = axis.InsertionPoint - axis.EndPoint;
var v = mainVector.CrossProduct(Vector3d.ZAxis).GetNormal();
axis.TopMarkerPoint = gripPoint.GripPoint + (offset.DotProduct(v) * v);
// Меняю также точку маркера-ориентира
if (_initTopOrientPoint != Point3d.Origin)
{
axis.TopOrientPoint = _initTopOrientPoint + (offset.DotProduct(v) * v);
}
}
if (gripPoint.GripName == AxisGripName.BottomOrientGrip)
{
var mainVector = axis.EndPoint - axis.InsertionPoint;
var v = mainVector.CrossProduct(Vector3d.ZAxis).GetNormal();
var newPoint = gripPoint.GripPoint + (offset.DotProduct(v) * v);
if (Math.Abs((newPoint - axis.BottomMarkerPoint).Length) >
axis.MarkersDiameter * scale)
{
axis.BottomOrientPoint = newPoint;
}
else
{
if (newPoint.X >= axis.BottomMarkerPoint.X)
{
axis.BottomOrientPoint =
axis.BottomMarkerPoint + (v * -1 * axis.MarkersDiameter * scale);
}
else
{
axis.BottomOrientPoint =
axis.BottomMarkerPoint + (v * axis.MarkersDiameter * scale);
}
}
}
if (gripPoint.GripName == AxisGripName.TopOrientGrip)
{
var mainVector = axis.InsertionPoint - axis.EndPoint;
var v = mainVector.CrossProduct(Vector3d.ZAxis).GetNormal();
var newPoint = gripPoint.GripPoint + (offset.DotProduct(v) * v);
if (Math.Abs((newPoint - axis.TopMarkerPoint).Length) >
axis.MarkersDiameter * scale)
{
axis.TopOrientPoint = newPoint;
}
else
{
if (newPoint.X >= axis.TopMarkerPoint.X)
{
axis.TopOrientPoint =
axis.TopMarkerPoint + (v * axis.MarkersDiameter * scale);
}
else
{
axis.TopOrientPoint =
axis.TopMarkerPoint + (v * -1 * axis.MarkersDiameter * scale);
}
}
}
// Вот тут происходит перерисовка примитивов внутри блока
axis.UpdateEntities();
axis.BlockRecord.UpdateAnonymousBlocks();
}
else
{
base.MoveGripPointsAt(entity, grips, offset, bitFlags);
}
}
}
else
{
base.MoveGripPointsAt(entity, grips, offset, bitFlags);
}
}
catch (Exception exception)
{
if (exception.ErrorStatus != ErrorStatus.NotAllowedForThisProxy)
{
ExceptionBox.Show(exception);
}
}
}
//移动夹点
public override void MoveGripPointsAt(Entity entity, GripDataCollection grips, Vector3d offset, MoveGripPointsFlags bitFlags)
{
LArrow3 la = new LArrow3(entity);
foreach (GripData gd in grips)
{
if (gd is LArrowGripData3)
{
LArrowGripData3 lagd = (LArrowGripData3)gd;
lagd.Move(la, offset);
}
}
for (int i = grips.Count - 1; i >= 0; i--)
{
if (grips[i] is LArrowGripData3)
{
grips.Remove(grips[i]);
}
}
if (grips.Count > 0)
{
base.MoveGripPointsAt(entity, grips, offset, bitFlags);
}
}
public override void MoveGripPointsAt(Entity entity, GripDataCollection grips, Vector3d offset, MoveGripPointsFlags bitFlags)
{
var wall = entity as Line;
if (wall != null)
{
var xdata = wall.GetXData(CommandJson.AppName);
var data = DBHelper.GetNODData(CommandJson.AppName, xdata[0].Value.ToString())?.Data?.AsArray();
var wallPara = JsonConvert.DeserializeObject <Wall>(
data[1].Value.ToString());
foreach (var grip in grips)
{
var wallGrip = grip as WallGripData;
if (wallGrip != null)
{
if (wallGrip.IsStartPoint)
{
wall.StartPoint = wallGrip.GripPoint + offset;
}
else
{
wall.EndPoint = wallGrip.GripPoint + offset;
}
}
wallPara.Pos.X = wall.StartPoint.X;
wallPara.Pos.Y = wall.StartPoint.Y;
wallPara.Dir.X = wall.EndPoint.X - wall.StartPoint.X;
wallPara.Dir.Y = wall.EndPoint.Y - wall.StartPoint.Y;
wallPara.Size.H = wall.Length;
var newData = new ResultBuffer(
new TypedValue((int)DxfCode.Text,
wallPara.GetType().ToString()),
new TypedValue((int)DxfCode.Text,
JsonConvert.SerializeObject(wallPara)
));
DBHelper.SetNODData(CommandJson.AppName, wall.Id.ToString(),
new Xrecord {
Data = newData
});
}
}
}
public override void MoveGripPointsAt(Entity entity, GripDataCollection grips, Vector3d offset, MoveGripPointsFlags bitFlags)
{
/*ArrowGripData gdata = new ArrowGripData();
* gdata.GripPoint = _getCustomGrip(entity);
* grips.Add(gdata);*/
base.MoveGripPointsAt(entity, grips, offset, bitFlags);
#if DEBUG
if (_entities != null)
{
IgorKL.ACAD3.Model.Tools.AppendEntity(_entities);
_entities = null;
}
#endif
}
