706 lines
24 KiB
C#
706 lines
24 KiB
C#
using MetroGauges.Controls.BlockShaps;
|
|
using MetroGauges.Database;
|
|
using MetroGauges.Database.Enitys;
|
|
using netDxf;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
using System.Windows;
|
|
using System.Windows.Controls;
|
|
using System.Windows.Input;
|
|
using System.Windows.Media;
|
|
using System.Windows.Shapes;
|
|
|
|
namespace MetroGauges.Controls
|
|
{
|
|
public class BlockData
|
|
{
|
|
|
|
private bool visblie;
|
|
|
|
public BlockInfo BlockEnity { get; set; }
|
|
|
|
public netDxf.Blocks.Block SourceBlock { get; set; }
|
|
|
|
public netDxf.Blocks.Block ReverseBlock { get; set; }
|
|
|
|
public List<FrameworkElement> Block { get; set; }
|
|
/// <summary>
|
|
/// 是否镜向
|
|
/// </summary>
|
|
public bool IsDirection { get; set; }
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// 是否能镜向
|
|
/// </summary>
|
|
public bool CanDirection { get; set; }
|
|
|
|
public bool Visblie {
|
|
|
|
get
|
|
{
|
|
return visblie;
|
|
}
|
|
set
|
|
{
|
|
visblie = value;
|
|
foreach (var item in this.Block)
|
|
{
|
|
if (visblie)
|
|
{
|
|
item.Visibility = Visibility.Visible;
|
|
}
|
|
else
|
|
{
|
|
item.Visibility = Visibility.Collapsed;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public string BlockName { get; set; }
|
|
|
|
public double Sclae { get; set; }
|
|
|
|
public string FilePath { get; set; }
|
|
|
|
public List<Point> BlockPoints { get; set; }
|
|
|
|
public BlockData() {
|
|
Sclae = 1;
|
|
Block = new List<FrameworkElement>();
|
|
BlockPoints = new List<Point>();
|
|
}
|
|
}
|
|
|
|
public class BlockManage
|
|
{
|
|
private BlockOpr m_blockOpr = new BlockOpr();
|
|
private string m_BlockPath;
|
|
private Canvas m_canvas;
|
|
private Dictionary<string, BlockData> m_Blocks = new Dictionary<string, BlockData>();
|
|
//原文件块数据
|
|
//private Dictionary<string, netDxf.Blocks.Block> sourceBlocks = new Dictionary<string, netDxf.Blocks.Block>();
|
|
|
|
private BlockData selectedBlock;
|
|
|
|
private double m_ScaleRale;
|
|
|
|
private System.Windows.Point dragPoint;
|
|
System.Windows.Point offset;
|
|
bool isInDrag = false;
|
|
|
|
public event EventHandler<HighlighEvent> HighlighEvent;
|
|
|
|
public bool IsView { get; set; }
|
|
public Point DragPoint {
|
|
set {
|
|
dragPoint = value;
|
|
}
|
|
}
|
|
|
|
public Dictionary<string, BlockData> Blocks
|
|
{
|
|
get {
|
|
return m_Blocks;
|
|
}
|
|
}
|
|
public BlockData SelectedBlock
|
|
{
|
|
get
|
|
{
|
|
return selectedBlock;
|
|
}
|
|
set
|
|
{
|
|
selectedBlock = value;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
public BlockManage(Canvas canvas, double scaleRale)
|
|
{
|
|
m_canvas = canvas;
|
|
m_ScaleRale = scaleRale;
|
|
m_BlockPath = AppDomain.CurrentDomain.BaseDirectory + "Blocks\\";
|
|
|
|
m_blockOpr.ScaleRale = m_ScaleRale;
|
|
//Ellipse ellipse = new Ellipse();
|
|
|
|
//Path path = AddCircle(new netDxf.Entities.Circle() { Center = new netDxf.Vector3() { X = 1000, Y = 1000 }, Radius=50 });
|
|
//path.Name = "圆";
|
|
//m_Blocks.Add( "圆", new List<Shape>() { path } );
|
|
|
|
//AddArc(null);
|
|
}
|
|
|
|
public List<BlockModel> BlockNames()
|
|
{
|
|
List<BlockModel> list = new List<BlockModel>();
|
|
try
|
|
{
|
|
string[] files= System.IO.Directory.GetFiles(m_BlockPath);
|
|
|
|
foreach (var item in files)
|
|
{
|
|
string name = System.IO.Path.GetFileNameWithoutExtension(item);
|
|
string[] names = name.Split('_');
|
|
|
|
list.Add(new BlockModel() { Name = names[0], FileName = name });
|
|
}
|
|
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
LogManager.WriteLog("DesingControl", "BlockNames:" + ex.Message);
|
|
MessageBox.Show("获取块数据异常","错误");
|
|
}
|
|
|
|
|
|
return list;
|
|
|
|
}
|
|
|
|
#region 图形移动
|
|
public void Element_MouseLeftButtonDown(object sender, MouseButtonEventArgs e)
|
|
{
|
|
FrameworkElement element = sender as FrameworkElement;
|
|
offset = e.GetPosition(element);
|
|
element.CaptureMouse();
|
|
isInDrag = true;
|
|
e.Handled = true;
|
|
|
|
dragPoint = e.GetPosition(m_canvas);
|
|
|
|
this.CopyBlock(element.Name);
|
|
|
|
this.HighlightBlock(element.Name);
|
|
//MessageBox.Show($"X:{offset.X}Y:{offset.Y}");
|
|
}
|
|
|
|
private void Element_MouseMove(object sender, MouseEventArgs e)
|
|
{
|
|
if (isInDrag)
|
|
{
|
|
FrameworkElement element = sender as FrameworkElement;
|
|
System.Windows.Point currentPoint = e.GetPosition(m_canvas);
|
|
|
|
//Canvas.SetLeft(element, currentPoint.X - offset.X);
|
|
//Canvas.SetTop(element, currentPoint.Y + offset.Y);
|
|
|
|
//Canvas.SetLeft(x_scale1, currentPoint.X - offset.X);
|
|
//Canvas.SetTop(x_scale1, currentPoint.Y + offset.Y);
|
|
|
|
MoveBlock(element.Name, currentPoint);
|
|
|
|
SendHighlighEvent(false);
|
|
}
|
|
}
|
|
|
|
|
|
private void Element_MouseLeftButtonUp(object sender, MouseButtonEventArgs e)
|
|
{
|
|
if (isInDrag)
|
|
{
|
|
FrameworkElement element = sender as FrameworkElement;
|
|
element.ReleaseMouseCapture();
|
|
isInDrag = false;
|
|
e.Handled = true;
|
|
|
|
if (!IsView)
|
|
{
|
|
SendHighlighEvent(true);
|
|
}
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
//高亮选择块
|
|
public void HighlightBlock(string blockname)
|
|
{
|
|
if (selectedBlock != null)
|
|
{
|
|
foreach (var item in selectedBlock.Block)
|
|
{
|
|
if (item is Shape)
|
|
{
|
|
(item as Shape).Stroke = Brushes.White;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
if (m_Blocks.ContainsKey(blockname))
|
|
{
|
|
selectedBlock = m_Blocks[blockname];
|
|
foreach (var item in selectedBlock.Block)
|
|
{
|
|
if (item is Shape)
|
|
{
|
|
(item as Shape).Stroke = Brushes.Red;
|
|
}
|
|
}
|
|
}
|
|
|
|
SendHighlighEvent(false);
|
|
|
|
}
|
|
|
|
public void SendHighlighEvent(bool isNeedUpdateDB)
|
|
{
|
|
if (HighlighEvent != null)
|
|
{
|
|
|
|
HighlighEvent e = new HighlighEvent() { Block = selectedBlock };
|
|
Point minPoint = new Point();
|
|
Point cenPoint = new Point();
|
|
m_blockOpr.GetBlockPoints(selectedBlock.Block, out minPoint, out cenPoint);
|
|
e.Location = minPoint;
|
|
HighlighEvent(this, e);
|
|
|
|
if (isNeedUpdateDB && selectedBlock.BlockEnity !=null)
|
|
{
|
|
//更新最后调整位置:矩形外框右下角位置
|
|
BlockDAL.UpdateBlockLocation(selectedBlock.BlockEnity.Id, minPoint.X, minPoint.Y);
|
|
selectedBlock.BlockEnity.Locationx = minPoint.X;
|
|
selectedBlock.BlockEnity.Locationy = minPoint.Y;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
public void RemoveBlock()
|
|
{
|
|
if (selectedBlock != null)
|
|
{
|
|
foreach (var item in selectedBlock.Block)
|
|
{
|
|
this.m_canvas.Children.Remove(item);
|
|
}
|
|
|
|
|
|
m_Blocks.Remove(selectedBlock.BlockName);
|
|
|
|
}
|
|
}
|
|
|
|
public void RemoveBlock(BlockData block)
|
|
{
|
|
if (block != null)
|
|
{
|
|
foreach (var item in block.Block)
|
|
{
|
|
this.m_canvas.Children.Remove(item);
|
|
}
|
|
m_Blocks.Remove(block.BlockName);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 添加 镜向块
|
|
/// </summary>
|
|
/// <returns></returns>
|
|
public Shape ReverseBlock()
|
|
{
|
|
Shape drapShape = null;
|
|
if (selectedBlock != null && selectedBlock.ReverseBlock !=null)
|
|
{
|
|
//RemoveBlock();
|
|
//drapShape = EntityToShap(selectedBlock.ReverseBlock, selectedBlock);
|
|
|
|
//selectedBlock.SourceBlock = selectedBlock.ReverseBlock;
|
|
|
|
//m_Blocks.Add(selectedBlock.BlockName, selectedBlock);
|
|
|
|
|
|
|
|
if (!selectedBlock.IsDirection)
|
|
{
|
|
TransformGroup tg = new TransformGroup();
|
|
ScaleTransform scale = new ScaleTransform() { ScaleX = -1 };
|
|
tg.Children.Add(scale);
|
|
foreach (var item in selectedBlock.Block)
|
|
{
|
|
item.RenderTransform = tg;
|
|
(item.DataContext as ShapDataContext).IsDirection = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
foreach (var item in selectedBlock.Block)
|
|
{
|
|
item.RenderTransform = null;
|
|
(item.DataContext as ShapDataContext).IsDirection = false;
|
|
}
|
|
}
|
|
|
|
selectedBlock.IsDirection = !selectedBlock.IsDirection;
|
|
}
|
|
|
|
return drapShape;
|
|
}
|
|
|
|
/// <summary>
|
|
/// 添加块图形
|
|
/// </summary>
|
|
/// <param name="blockname"></param>
|
|
public Shape AddBlock(string blockname,bool isDirection =false)
|
|
{
|
|
Shape drapShape = null;
|
|
try
|
|
{
|
|
|
|
blockname = blockname.Replace(".dxf","");
|
|
if (!string.IsNullOrEmpty(blockname))
|
|
{
|
|
string bName = blockname + "_" + (m_Blocks.Count+1);
|
|
BlockData blockData = new BlockData() { BlockName=bName, IsDirection= isDirection };
|
|
m_Blocks.Add(bName, blockData);
|
|
string file = m_BlockPath + blockname + ".dxf";
|
|
blockData.FilePath = file;
|
|
//string[] names = blockname.Split('_');
|
|
|
|
netDxf.DxfDocument dxf = netDxf.DxfDocument.Load(file);
|
|
blockData.SourceBlock=dxf.Blocks[blockname];
|
|
//blockData.ReverseBlock= dxf.Blocks[names[0]+"B"];
|
|
|
|
//foreach (var blName in names) //根据命名规侧循环嵌套的块
|
|
//{
|
|
if (dxf.Blocks.Contains(blockname))
|
|
{
|
|
netDxf.Blocks.Block block = dxf.Blocks[blockname];
|
|
drapShape = EntityToShap(block, blockData);
|
|
}
|
|
// }
|
|
|
|
return drapShape;
|
|
|
|
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
LogManager.WriteLog("DesingControl", "AddBlock:" + ex.Message);
|
|
MessageBox.Show("读取块数据异常","错误");
|
|
|
|
}
|
|
return drapShape;
|
|
}
|
|
|
|
private Shape EntityToShap(netDxf.Blocks.Block block, BlockData blockData)
|
|
{
|
|
Shape drapShape = null;
|
|
for (int i = 0; i < block.Entities.Count; i++)
|
|
{
|
|
netDxf.Entities.EntityObject item = block.Entities[i];
|
|
switch (item.Type.ToString())
|
|
{
|
|
case "Line":
|
|
Line line = AddLine(item);
|
|
line.Name = blockData.BlockName;
|
|
blockData.Block.Add(line);
|
|
drapShape = line;
|
|
item.DataContext = line;
|
|
break;
|
|
case "Polyline":
|
|
case "LightWeightPolyline":
|
|
Polyline ply = AddPolyline(item);
|
|
ply.Name = blockData.BlockName;
|
|
blockData.Block.Add(ply);
|
|
drapShape = new Line() { X1 = ply.Points[0].X, Y1 = ply.Points[1].Y, Name = blockData.BlockName };
|
|
item.DataContext = ply;
|
|
break;
|
|
case "Circle":
|
|
Path circle = AddCircle(item);
|
|
circle.Name = blockData.BlockName;
|
|
blockData.Block.Add(circle);
|
|
EllipseGeometry cir = circle.Data as EllipseGeometry;
|
|
drapShape = new Line() { X1 = cir.Center.X, Y1 = cir.Center.Y, Name = blockData.BlockName };
|
|
item.DataContext = circle;
|
|
break;
|
|
case "Arc":
|
|
Path arc = AddArc(item);
|
|
arc.Name = blockData.BlockName;
|
|
blockData.Block.Add(arc);
|
|
drapShape = arc;
|
|
item.DataContext = arc;
|
|
break;
|
|
}
|
|
|
|
//记录反转的块的某个点，作为插入块时的偏移计算
|
|
if (blockData.ReverseBlock != null)
|
|
{
|
|
blockData.ReverseBlock.Entities[i].DataContext = drapShape;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
return drapShape;
|
|
}
|
|
|
|
|
|
#region 添加图形到画板中
|
|
public Line AddLine(netDxf.Entities.EntityObject line)
|
|
{
|
|
double xyRate = m_ScaleRale;
|
|
Line drawline = new Line() { Cursor =Cursors.Hand };
|
|
netDxf.Entities.Line dataLine = line as netDxf.Entities.Line;
|
|
drawline.X1 = dataLine.StartPoint.X / xyRate;
|
|
drawline.Y1 = -dataLine.StartPoint.Y / xyRate;
|
|
|
|
drawline.X2 = dataLine.EndPoint.X / xyRate;
|
|
drawline.Y2 = -dataLine.EndPoint.Y / xyRate;
|
|
|
|
drawline.Stroke = Brushes.White;
|
|
drawline.StrokeThickness = 0.5;
|
|
|
|
drawline.MouseLeftButtonDown += Element_MouseLeftButtonDown;
|
|
drawline.MouseMove += Element_MouseMove;
|
|
drawline.MouseLeftButtonUp += Element_MouseLeftButtonUp;
|
|
|
|
|
|
// 保存原始坐标
|
|
drawline.DataContext = new ShapDataContext() { OringLocation = new Line() { X1 = drawline.X1, Y1 = drawline.Y1, X2 = drawline.X2, Y2 = drawline.Y2 } };
|
|
m_canvas.Children.Add(drawline);
|
|
|
|
return drawline;
|
|
}
|
|
|
|
|
|
|
|
public Polyline AddPolyline(netDxf.Entities.EntityObject line)
|
|
{
|
|
double xyRate = m_ScaleRale;
|
|
PointCollection ptcol = new PointCollection();
|
|
bool isClosed = false;
|
|
switch (line.Type.ToString())
|
|
{
|
|
case "Polyline":
|
|
netDxf.Entities.Polyline polyline = line as netDxf.Entities.Polyline;
|
|
foreach (netDxf.Entities.PolylineVertex item in polyline.Vertexes)
|
|
{
|
|
ptcol.Add(new Point() { X = item.Location.X / xyRate, Y = -item.Location.Y / xyRate });
|
|
}
|
|
if (polyline.IsClosed)
|
|
{
|
|
netDxf.Vector3 last = polyline.Vertexes[0].Location;
|
|
ptcol.Add(new Point() { X = last.X / xyRate, Y = -last.Y / xyRate });
|
|
}
|
|
isClosed = polyline.IsClosed;
|
|
break;
|
|
case "LightWeightPolyline":
|
|
netDxf.Entities.LwPolyline lwline = line as netDxf.Entities.LwPolyline;
|
|
foreach (var item in lwline.Vertexes)
|
|
{
|
|
ptcol.Add(new Point() { X = item.Location.X / xyRate, Y = -item.Location.Y / xyRate });
|
|
}
|
|
if (lwline.IsClosed)
|
|
{
|
|
netDxf.Vector2 last = lwline.Vertexes[0].Location;
|
|
ptcol.Add(new Point() { X = last.X / xyRate, Y = -last.Y / xyRate });
|
|
}
|
|
|
|
isClosed = lwline.IsClosed;
|
|
break;
|
|
}
|
|
Polyline pl = new Polyline
|
|
{
|
|
Stroke = Brushes.White,
|
|
StrokeThickness = 0.5,
|
|
Points = ptcol,
|
|
Cursor = Cursors.Hand
|
|
};
|
|
pl.MouseLeftButtonDown += Element_MouseLeftButtonDown;
|
|
pl.MouseMove += Element_MouseMove;
|
|
pl.MouseLeftButtonUp += Element_MouseLeftButtonUp;
|
|
|
|
|
|
// 保存原始坐标
|
|
pl.DataContext = new ShapDataContext() { OringLocation = pl.Points, IsClosed= isClosed };
|
|
|
|
m_canvas.Children.Add(pl);
|
|
|
|
return pl;
|
|
}
|
|
|
|
public Path AddCircle(netDxf.Entities.EntityObject circle1)
|
|
{
|
|
netDxf.Entities.Circle circle = circle1 as netDxf.Entities.Circle;
|
|
double xyRate = m_ScaleRale;
|
|
|
|
Path path = new Path() { Stroke = new SolidColorBrush(Colors.White), StrokeThickness = 0.5, Cursor = Cursors.Hand };
|
|
|
|
EllipseGeometry ellipseGeometry = new EllipseGeometry() { RadiusX = circle.Radius / xyRate, RadiusY = circle.Radius/ xyRate, Center = new Point() { X = circle.Center.X/ xyRate, Y = -circle.Center.Y / xyRate } };
|
|
path.Data = ellipseGeometry;
|
|
|
|
path.MouseLeftButtonDown += Element_MouseLeftButtonDown;
|
|
path.MouseMove += Element_MouseMove;
|
|
path.MouseLeftButtonUp += Element_MouseLeftButtonUp;
|
|
|
|
|
|
|
|
//保存原始坐标
|
|
EllipseGeometry geometry = new EllipseGeometry();
|
|
geometry.Center = new Point() { X = ellipseGeometry.Center.X, Y = ellipseGeometry.Center.Y };
|
|
geometry.RadiusX = ellipseGeometry.RadiusX;
|
|
geometry.RadiusY = ellipseGeometry.RadiusY;
|
|
path.DataContext = new ShapDataContext() { OringLocation = geometry };
|
|
|
|
|
|
m_canvas.Children.Add(path);
|
|
|
|
return path;
|
|
}
|
|
public Path AddArc(netDxf.Entities.EntityObject arc1)
|
|
{
|
|
netDxf.Entities.Arc arc = arc1 as netDxf.Entities.Arc;
|
|
|
|
Path path = new Path() { Cursor = Cursors.Hand };
|
|
path.MouseLeftButtonDown += Element_MouseLeftButtonDown;
|
|
path.MouseMove += Element_MouseMove;
|
|
path.MouseLeftButtonUp += Element_MouseLeftButtonUp;
|
|
|
|
|
|
double startAngleInRadian = arc.StartAngle * Math.PI / 180.0;
|
|
double endAngleInRadian = arc.EndAngle * Math.PI / 180.0;
|
|
|
|
Point arcStartPt = new Point();
|
|
Point arcEndPt = new Point();
|
|
arcStartPt.X = arc.Center.X + arc.Radius * Math.Cos(startAngleInRadian);
|
|
arcStartPt.Y = arc.Center.Y + arc.Radius * Math.Sin(startAngleInRadian);
|
|
|
|
|
|
arcEndPt.X = arc.Center.X + arc.Radius * Math.Cos(endAngleInRadian);
|
|
arcEndPt.Y = arc.Center.Y + arc.Radius * Math.Sin(endAngleInRadian);
|
|
|
|
|
|
PathGeometry pathGeometry = new PathGeometry();
|
|
ArcSegment arcs = new ArcSegment(new Point(arcEndPt.X/ m_ScaleRale, -arcEndPt.Y/ m_ScaleRale), new Size(arc.Radius/ m_ScaleRale, arc.Radius/ m_ScaleRale), 0, false, SweepDirection.Counterclockwise, true);
|
|
PathFigure figure = new PathFigure();
|
|
|
|
figure.StartPoint = new Point(arcStartPt.X/ m_ScaleRale, -arcStartPt.Y/ m_ScaleRale);
|
|
figure.Segments.Add(arcs);
|
|
pathGeometry.Figures.Add(figure);
|
|
|
|
path.Data = pathGeometry;
|
|
path.Stroke = Brushes.White;
|
|
path.StrokeThickness = 0.5;
|
|
|
|
arc.Center = new Vector3() { X = arc.Center.X / m_ScaleRale, Y = -arc.Center.Y / m_ScaleRale };
|
|
arc.Radius = arc.Radius / m_ScaleRale;
|
|
ShapDataContext shapDataContext =new ShapDataContext() { Arc=arc }; //new Point() { X = arc.Center.X, Y = arc.Center.Y };
|
|
path.DataContext = shapDataContext;
|
|
|
|
////保存原始坐标
|
|
List<Point> ps = new List<Point>();
|
|
ps.Add(new Point() { X = figure.StartPoint.X, Y = figure.StartPoint.Y });
|
|
ps.Add(new Point() { X = arcs.Point.X, Y = arcs.Point.Y });
|
|
ps.Add(new Point() { X = shapDataContext.Arc.Center.X, Y = shapDataContext.Arc.Center.Y });
|
|
|
|
|
|
shapDataContext.OringLocation = ps;
|
|
|
|
m_canvas.Children.Add(path);
|
|
return path;
|
|
}
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// 导出所有的多块图形
|
|
/// </summary>
|
|
/// <param name="dxf"></param>
|
|
/// <param name="layer"></param>
|
|
public void DrawDxfBlocks(netDxf.DxfDocument dxf, netDxf.Tables.Layer layer)
|
|
{
|
|
Dictionary<string, BlockData> blocks = m_Blocks;
|
|
foreach (var item in blocks)
|
|
{
|
|
List<FrameworkElement> block = item.Value.Block;
|
|
|
|
m_blockOpr.dxf = dxf;
|
|
m_blockOpr.layer = layer;
|
|
m_blockOpr.BlockData = item.Value;
|
|
//m_blockOpr.ExctecOpr(block, OprType.DrawDxfBlocks);
|
|
|
|
m_blockOpr.ExctecOpr(block, OprType.ExportSourceBlock);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// 设置块图形的原始坐标 计算拖动使用
|
|
/// </summary>
|
|
/// <param name="blockname"></param>
|
|
public void CopyBlock( string blockname )
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(blockname))
|
|
{
|
|
List<FrameworkElement> block = m_Blocks[blockname].Block;
|
|
m_blockOpr.ExctecOpr(block, OprType.CopyBlock);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
public void MoveBlock(string blockName, System.Windows.Point currentPoint)
|
|
{
|
|
BlockData blockData = m_Blocks[blockName];
|
|
|
|
if (blockData.BlockEnity !=null && blockData.BlockEnity.Istemplate == 0)
|
|
{
|
|
List<FrameworkElement> blocks = blockData.Block;
|
|
m_blockOpr.currentPoint = currentPoint;
|
|
m_blockOpr.dragPoint = dragPoint;
|
|
m_blockOpr.ExctecOpr(blocks, OprType.MoveBlock);
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
public void ScaleBlock( double rate)
|
|
{
|
|
if (selectedBlock != null && rate!=0)
|
|
{
|
|
this.CopyBlock(selectedBlock.BlockName);
|
|
m_blockOpr.rate = rate;
|
|
List<FrameworkElement> block = selectedBlock.Block;
|
|
selectedBlock.Sclae = rate;
|
|
if (selectedBlock != null )
|
|
{
|
|
m_blockOpr.ExctecOpr(block, OprType.ScaleBlock);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
public void MoveBlockByX(string blockName, double x)
|
|
{
|
|
List<FrameworkElement> blocks = m_Blocks[blockName].Block;
|
|
|
|
m_blockOpr.currentPoint = new Point() { X =x };
|
|
m_blockOpr.ExctecOpr(blocks, OprType.MoveByX);
|
|
|
|
}
|
|
|
|
public void MoveBlockByY(string blockName, double y)
|
|
{
|
|
List<FrameworkElement> blocks = m_Blocks[blockName].Block;
|
|
|
|
m_blockOpr.currentPoint = new Point() { Y = y };
|
|
m_blockOpr.ExctecOpr(blocks, OprType.MoveByY);
|
|
|
|
}
|
|
|
|
}
|
|
}
|