976 lines
34 KiB
C#
976 lines
34 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using System.Drawing;
|
||
using System.Reflection;
|
||
using System.Text.Json;
|
||
using System.Xml;
|
||
|
||
namespace CoreUnit.Control.UserControl.Canvas
|
||
{
|
||
public class AddObjectParam
|
||
{
|
||
public string ObjectType;
|
||
public UnitPoint Point1;
|
||
public UnitPoint Point2;
|
||
public UnitPoint Center;
|
||
public float StartAngle;
|
||
public float EndAngle;
|
||
public float MajorRadius;
|
||
public float MinorRadius;
|
||
public Color Color = Color.White;
|
||
public float RotateAngle;
|
||
}
|
||
|
||
public class DataModel : IModel
|
||
{
|
||
static Dictionary<string, Type> m_toolTypes = new Dictionary<string, Type>();
|
||
static public IDrawObject NewDrawObject(string objecttype)
|
||
{
|
||
if (m_toolTypes.ContainsKey(objecttype)) {
|
||
string type = m_toolTypes[objecttype].ToString();
|
||
IDrawObject drawObj = Assembly.GetExecutingAssembly().CreateInstance(type) as IDrawObject;
|
||
return drawObj;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
Dictionary<string, IDrawObject> m_drawObjectTypes = new Dictionary<string, IDrawObject>();
|
||
DrawObjectBase CreateObject(string objecttype)
|
||
{
|
||
if (m_drawObjectTypes.ContainsKey(objecttype)) {
|
||
return m_drawObjectTypes[objecttype].Clone() as DrawObjectBase;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
Dictionary<string, IEditTool> m_editTools = new Dictionary<string, IEditTool>();
|
||
public void AddEditTool(string key, IEditTool tool)
|
||
{
|
||
m_editTools.Add(key, tool);
|
||
}
|
||
|
||
public bool IsDirty {
|
||
get { return m_undoBuffer.Dirty; }
|
||
}
|
||
|
||
UndoRedoBuffer m_undoBuffer = new UndoRedoBuffer();
|
||
|
||
UnitPoint m_centerPoint = UnitPoint.Empty;
|
||
|
||
public UnitPoint CenterPoint {
|
||
get { return m_centerPoint; }
|
||
set { m_centerPoint = value; }
|
||
}
|
||
|
||
float m_scaleToFit = 0;//zoom fit¿¡ ¸Â´Â ½ºÄÉÀÏ °ª
|
||
public float ScaleToFit {
|
||
get { return m_scaleToFit; }
|
||
set { m_scaleToFit = value; }
|
||
}
|
||
|
||
float m_zoom = 1;
|
||
ICanvasLayer m_gridLayer = new GridLayer();
|
||
ICanvasLayer m_backgroundLayer = new BackgroundLayer();
|
||
List<ICanvasLayer> m_layers = new List<ICanvasLayer>();
|
||
ICanvasLayer m_activeLayer;
|
||
Dictionary<IDrawObject, bool> m_selection = new Dictionary<IDrawObject, bool>();
|
||
|
||
public delegate void EventHandlerCopyObjects(List<IDrawObject> objectList);
|
||
public EventHandlerCopyObjects evtCopyObjects;
|
||
|
||
public delegate void EventHandlerAddObject(IDrawObject obj);
|
||
public EventHandlerAddObject evtAddObject;
|
||
|
||
public delegate void EventHandlerDeleteObjects(List<IDrawObject> objectList);
|
||
public EventHandlerDeleteObjects evtDeleteObjects;
|
||
|
||
public delegate void EventHandlerMoveObjects(List<IDrawObject> originalObjectList, List<IDrawObject> newObjectList);
|
||
public EventHandlerMoveObjects evtMoveObjects;
|
||
|
||
public delegate void EventHandlerMoveNodes(List<INodePoint> nodes);
|
||
public EventHandlerMoveNodes evtMoveNodes;
|
||
|
||
public delegate void EventHandlerSelectObjects(List<IDrawObject> objects);
|
||
public EventHandlerSelectObjects evtSelectObjects;
|
||
|
||
public delegate void EventHandlerDeselectAllObjects();
|
||
public EventHandlerDeselectAllObjects evtDeselectAllObjects;
|
||
|
||
public delegate void EventHandlerRedo();
|
||
public EventHandlerRedo evtRedo;
|
||
|
||
public delegate void EventHandlerUndo();
|
||
public EventHandlerUndo evtUndo;
|
||
|
||
public DataModel()
|
||
{
|
||
m_toolTypes.Clear();
|
||
|
||
m_toolTypes[Line.ObjectType] = typeof(Line);
|
||
m_toolTypes[Circle.ObjectType] = typeof(Circle);
|
||
m_toolTypes[Arc.ObjectType] = typeof(Arc);
|
||
m_toolTypes[Arc3Point.ObjectType] = typeof(Arc3Point);
|
||
m_toolTypes[Dot.ObjectType] = typeof(Dot);
|
||
m_toolTypes[Spline.ObjectType] = typeof(Spline);
|
||
m_toolTypes[SnowMan.ObjectType] = typeof(SnowMan);
|
||
m_toolTypes[ZigZag.ObjectType] = typeof(ZigZag);
|
||
//group tool ŸÀÔ »ý¼º
|
||
m_toolTypes[Group.ObjectType] = typeof(Group);
|
||
m_toolTypes[EllipseTool.ObjectType] = typeof(EllipseTool);
|
||
m_toolTypes[RectangleTool.ObjectType] = typeof(RectangleTool);
|
||
m_toolTypes[RoiTool.ObjectType] = typeof(RoiTool);
|
||
|
||
m_centerPoint = new UnitPoint(0, 0);
|
||
|
||
DefaultLayer();
|
||
}
|
||
|
||
public void AddDrawTool(string key, IDrawObject drawtool)
|
||
{
|
||
m_drawObjectTypes[key] = drawtool;
|
||
if (!m_toolTypes.ContainsKey(key)) {
|
||
m_toolTypes[key] = drawtool.GetType();
|
||
}
|
||
}
|
||
|
||
void DefaultLayer()
|
||
{
|
||
m_layers.Clear();
|
||
m_layers.Add(new DrawingLayer(m_layers.Count, string.Empty, Color.Black, 0.01f));
|
||
}
|
||
|
||
public IDrawObject GetFirstSelected()
|
||
{
|
||
if (m_selection.Count > 0) {
|
||
Dictionary<IDrawObject, bool>.KeyCollection.Enumerator e = m_selection.Keys.GetEnumerator();
|
||
e.MoveNext();
|
||
return e.Current;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
public IDrawObject GetLastSelected()
|
||
{
|
||
if (m_selection.Count > 0) {
|
||
Dictionary<IDrawObject, bool>.KeyCollection.Enumerator e = m_selection.Keys.GetEnumerator();
|
||
IDrawObject drawObject = null;
|
||
while (e.MoveNext()) { drawObject = e.Current; }
|
||
return drawObject;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
#region IModel Members
|
||
|
||
public float Zoom {
|
||
get { return m_zoom; }
|
||
set { m_zoom = value; }
|
||
}
|
||
|
||
public ICanvasLayer BackgroundLayer {
|
||
get { return m_backgroundLayer; }
|
||
set { m_backgroundLayer = value; }
|
||
}
|
||
|
||
public ICanvasLayer GridLayer {
|
||
get { return m_gridLayer; }
|
||
set { m_gridLayer = value; }
|
||
}
|
||
|
||
public ICanvasLayer[] Layers {
|
||
get { return m_layers.ToArray(); }
|
||
}
|
||
|
||
public ICanvasLayer ActiveLayer {
|
||
get {
|
||
if (m_activeLayer == null)
|
||
m_activeLayer = m_layers[0];
|
||
return m_activeLayer;
|
||
}
|
||
set {
|
||
m_activeLayer = value;
|
||
}
|
||
}
|
||
|
||
public ICanvasLayer GetLayer(int no)
|
||
{
|
||
foreach (ICanvasLayer layer in m_layers) {
|
||
if (layer.No == no)
|
||
return layer;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
public ICanvasLayer CreateLayer()
|
||
{
|
||
ICanvasLayer layer = new DrawingLayer(m_layers.Count, string.Empty, Color.Black, 0.01f);
|
||
m_layers.Add(layer);
|
||
m_activeLayer = layer;
|
||
return layer;
|
||
}
|
||
|
||
public void DeleteLayer(int no)
|
||
{
|
||
if (m_layers.Count <= 1) {
|
||
throw new Exception("ERR_SCANNER_CANVAS_USER_CONTROL_NOT_DELETE_DEFAULT_LAYER");
|
||
}
|
||
|
||
ICanvasLayer deleteLayer = GetLayer(no);
|
||
m_layers.Remove(deleteLayer);
|
||
|
||
for (int i = 0; i < m_layers.Count; i++) {
|
||
ICanvasLayer layer = m_layers[i];
|
||
layer.No = i;
|
||
}
|
||
|
||
ActiveLayer = m_layers[0];
|
||
}
|
||
|
||
public void ChangeLayer(int no)
|
||
{
|
||
foreach (ICanvasLayer layer in m_layers) {
|
||
if (layer.No == no) {
|
||
ActiveLayer = layer;
|
||
ClearSelectedObjects();
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
|
||
public void CopyLayer(int no)
|
||
{
|
||
ICanvasLayer targetLayer = GetLayer(no);
|
||
ICanvasLayer newLayer = CreateLayer();
|
||
((DrawingLayer)newLayer).Copy((DrawingLayer)targetLayer, true);
|
||
}
|
||
|
||
public IDrawObject CreateObject(string type, UnitPoint point, ISnapPoint snappoint)
|
||
{
|
||
DrawingLayer layer = ActiveLayer as DrawingLayer;
|
||
|
||
if (layer.Enabled == false) {
|
||
return null;
|
||
}
|
||
|
||
DrawObjectBase newobj = CreateObject(type);
|
||
|
||
if (newobj != null) {
|
||
(newobj as IDrawObject).No = layer.Objects.Count;
|
||
newobj.Layer = layer;
|
||
newobj.InitializeFromModel(point, layer, snappoint);
|
||
}
|
||
|
||
return newobj as IDrawObject;
|
||
}
|
||
|
||
public void AddObject(ICanvasLayer layer, IDrawObject drawobject, bool useEventMode = true)
|
||
{
|
||
if (drawobject is IObjectEditInstance) {
|
||
drawobject = ((IObjectEditInstance)drawobject).GetDrawObject();
|
||
}
|
||
|
||
if (m_undoBuffer.CanCapture) {
|
||
m_undoBuffer.AddCommand(new EditCommandAdd(layer, drawobject));
|
||
}
|
||
|
||
//°´Ã¼ÀÇ À̸§À» ¸í¸í
|
||
drawobject.No = layer.Objects.Count;
|
||
/////////////////////////////////////////////////
|
||
|
||
((DrawingLayer)layer).AddObject(drawobject);
|
||
// ±×¸®ÀÚ¸¶ÀÚ ¼±ÅõÊ,
|
||
AddSelectedObject(drawobject);
|
||
|
||
if (useEventMode == true) {
|
||
evtAddObject(drawobject);
|
||
}
|
||
}
|
||
|
||
public void DeleteObjects(List<IDrawObject> objects, bool useEventMode = true)
|
||
{
|
||
if (m_undoBuffer.CanCapture) {
|
||
m_undoBuffer.AddCommand(new EditCommandRemove(ActiveLayer, objects));
|
||
}
|
||
|
||
((DrawingLayer)ActiveLayer).DeleteObjects(objects);
|
||
|
||
//°´Ã¼ »èÁ¦ ÈÄ À̸§À» Àç ¸í¸í(hochul.kim)
|
||
for (int i = 0; i < ActiveLayer.Objects.Count; i++) {
|
||
IDrawObject obj = ActiveLayer.Objects[i];
|
||
obj.No = i;
|
||
}
|
||
/////////////////////////////////////////////////
|
||
|
||
if (useEventMode == true) {
|
||
evtDeleteObjects(objects);
|
||
}
|
||
}
|
||
|
||
public void MoveObjects(UnitPoint offset, List<IDrawObject> objects, bool useEventMode = true)
|
||
{
|
||
if (m_undoBuffer.CanCapture) {
|
||
m_undoBuffer.AddCommand(new EditCommandMove(offset, objects));
|
||
}
|
||
|
||
List<IDrawObject> originalObjects = new List<IDrawObject>();
|
||
foreach (IDrawObject obj in objects) {
|
||
IDrawObject newobj = obj.Clone();
|
||
originalObjects.Add(newobj);
|
||
}
|
||
|
||
foreach (IDrawObject obj in objects) {
|
||
obj.Move(offset);
|
||
}
|
||
|
||
if (useEventMode == true) {
|
||
evtMoveObjects(originalObjects, objects);
|
||
}
|
||
}
|
||
|
||
public void RotateObjects(float angle, List<IDrawObject> objects, bool useObjCenter, bool useEventMode = true)
|
||
{
|
||
if (m_undoBuffer.CanCapture) {
|
||
m_undoBuffer.AddCommand(new EditCommandRotate(angle, objects));
|
||
}
|
||
|
||
// ¿øº» °´Ã¼¿¡ ´ëÇÏ¿© ÀúÀåÇÔ
|
||
List<IDrawObject> originalObjects = new List<IDrawObject>();
|
||
foreach (IDrawObject obj in objects) {
|
||
IDrawObject newobj = obj.Clone();
|
||
originalObjects.Add(newobj);
|
||
}
|
||
|
||
foreach (IDrawObject obj in objects) {
|
||
UnitPoint center = useObjCenter ? new UnitPoint(obj.MiddlePoint.X, obj.MiddlePoint.Y) : new UnitPoint(0, 0);
|
||
obj.Rotate(angle, center);
|
||
}
|
||
|
||
if (useEventMode == true) {
|
||
evtMoveObjects(originalObjects, objects);
|
||
}
|
||
}
|
||
|
||
public void SizeObjects(float distance, List<IDrawObject> objects, bool useEventMode = true)
|
||
{
|
||
if (m_undoBuffer.CanCapture) {
|
||
m_undoBuffer.AddCommand(new EditCommandMakeLength(distance, objects));
|
||
}
|
||
|
||
// ¿øº» °´Ã¼¿¡ ´ëÇÏ¿© ÀúÀåÇÔ
|
||
List<IDrawObject> originalObjects = new List<IDrawObject>();
|
||
foreach (IDrawObject obj in objects) {
|
||
IDrawObject newobj = obj.Clone();
|
||
originalObjects.Add(newobj);
|
||
}
|
||
|
||
foreach (IDrawObject obj in objects) {
|
||
obj.MakeLength(distance);
|
||
}
|
||
|
||
if (useEventMode == true) {
|
||
evtMoveObjects(originalObjects, objects);
|
||
}
|
||
}
|
||
|
||
List<IDrawObject> m_selectedCopyObject;
|
||
public List<IDrawObject> SelectedCopyObject {
|
||
get {
|
||
return m_selectedCopyObject;
|
||
}
|
||
set {
|
||
m_selectedCopyObject = value;
|
||
}
|
||
}
|
||
|
||
bool m_isCopying = false;
|
||
public bool IsArrayCopying {
|
||
get { return m_isCopying; }
|
||
set { m_isCopying = value; }
|
||
}
|
||
|
||
public void AddSelectedObjects(List<IDrawObject> objects)
|
||
{
|
||
foreach (IDrawObject drawobject in objects) {
|
||
DrawObjectBase obj = drawobject as DrawObjectBase;
|
||
RemoveSelectedObject(drawobject);
|
||
m_selection[drawobject] = true;
|
||
obj.Selected = true;
|
||
}
|
||
}
|
||
|
||
int m_copyCnt = 0;
|
||
public int CopyCnt {
|
||
get { return m_copyCnt; }
|
||
set { m_copyCnt = value; }
|
||
}
|
||
|
||
public void CopyObjects(UnitPoint offset, List<IDrawObject> objects, bool useEventMode = true)
|
||
{
|
||
ClearSelectedObjects();
|
||
|
||
List<IDrawObject> newobjects = new List<IDrawObject>();
|
||
|
||
foreach (IDrawObject obj in objects) {
|
||
IDrawObject newobj = obj.Clone();
|
||
newobjects.Add(newobj);
|
||
newobj.Move(offset);
|
||
|
||
AddObject(ActiveLayer, newobj, useEventMode);
|
||
|
||
if (IsArrayCopying) {
|
||
SelectedCopyObject.Add(newobj);
|
||
AddSelectedObjects(SelectedCopyObject);
|
||
} else AddSelectedObject(newobj);
|
||
}
|
||
|
||
if (m_undoBuffer.CanCapture) {
|
||
m_undoBuffer.AddCommand(new EditCommandAdd(ActiveLayer, newobjects));
|
||
}
|
||
|
||
if (useEventMode == true) {
|
||
if (IsArrayCopying) newobjects = SelectedCopyObject;
|
||
|
||
evtCopyObjects(newobjects);
|
||
}
|
||
}
|
||
|
||
public void AfterEditObjects(IEditTool edittool)
|
||
{
|
||
edittool.Finished();
|
||
if (m_undoBuffer.CanCapture) {
|
||
m_undoBuffer.AddCommand(new EditCommandEditTool(edittool));
|
||
}
|
||
}
|
||
|
||
public IEditTool GetEditTool(string edittoolid)
|
||
{
|
||
if (m_editTools.ContainsKey(edittoolid))
|
||
return m_editTools[edittoolid].Clone();
|
||
return null;
|
||
}
|
||
|
||
public void MoveNodes(UnitPoint position, List<INodePoint> nodes, bool useEventMode = true)
|
||
{
|
||
if (m_undoBuffer.CanCapture) {
|
||
m_undoBuffer.AddCommand(new EditCommandNodeMove(nodes));
|
||
}
|
||
|
||
foreach (INodePoint node in nodes) {
|
||
node.SetPosition(position);
|
||
node.Finish();
|
||
}
|
||
|
||
if (useEventMode == true) {
|
||
evtMoveNodes(nodes);
|
||
}
|
||
}
|
||
|
||
public List<IDrawObject> GetHitObjects(ICanvas canvas, RectangleF selection, bool anyPoint)
|
||
{
|
||
List<IDrawObject> selected = new List<IDrawObject>();
|
||
|
||
foreach (IDrawObject drawobject in ActiveLayer.Objects) {
|
||
if (drawobject.ObjectInRectangle(canvas, selection, anyPoint)) {
|
||
selected.Add(drawobject);
|
||
}
|
||
}
|
||
|
||
return selected;
|
||
}
|
||
|
||
public List<IDrawObject> GetHitObjects(ICanvas canvas, UnitPoint point)
|
||
{
|
||
List<IDrawObject> selected = new List<IDrawObject>();
|
||
|
||
foreach (IDrawObject drawobject in ActiveLayer.Objects) {
|
||
if (drawobject.PointInObject(canvas, point)) {
|
||
selected.Add(drawobject);
|
||
}
|
||
}
|
||
|
||
return selected;
|
||
}
|
||
|
||
public bool IsSelected(IDrawObject drawobject)
|
||
{
|
||
return m_selection.ContainsKey(drawobject);
|
||
}
|
||
|
||
public void AddSelectedObject(IDrawObject drawobject)
|
||
{
|
||
DrawObjectBase obj = drawobject as DrawObjectBase;
|
||
RemoveSelectedObject(drawobject);
|
||
m_selection[drawobject] = true;
|
||
obj.Selected = true;
|
||
}
|
||
|
||
public void RemoveSelectedObject(IDrawObject drawobject)
|
||
{
|
||
if (m_selection.ContainsKey(drawobject)) {
|
||
DrawObjectBase obj = drawobject as DrawObjectBase;
|
||
obj.Selected = false;
|
||
m_selection.Remove(drawobject);
|
||
}
|
||
}
|
||
|
||
public List<IDrawObject> SelectedObjects {
|
||
get {
|
||
List<IDrawObject> obj = new List<IDrawObject>();
|
||
obj.AddRange(m_selection.Keys);
|
||
return obj;
|
||
}
|
||
}
|
||
|
||
public int SelectedCount {
|
||
get { return m_selection.Count; }
|
||
}
|
||
|
||
public void ClearSelectedObjects()
|
||
{
|
||
List<IDrawObject> x = SelectedObjects;
|
||
foreach (IDrawObject drawobject in x) {
|
||
DrawObjectBase obj = drawobject as DrawObjectBase;
|
||
obj.Selected = false;
|
||
}
|
||
|
||
m_selection.Clear();
|
||
}
|
||
|
||
public ISnapPoint SnapPoint(ICanvas canvas, UnitPoint point, Type[] runningsnaptypes, Type usersnaptype)
|
||
{
|
||
List<IDrawObject> objects = GetHitObjects(canvas, point);
|
||
if (objects.Count == 0)
|
||
return null;
|
||
|
||
foreach (IDrawObject obj in objects) {
|
||
ISnapPoint snap = obj.SnapPoint(canvas, point, objects, runningsnaptypes, usersnaptype);
|
||
if (snap != null)
|
||
return snap;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
public bool CanUndo()
|
||
{
|
||
return m_undoBuffer.CanUndo;
|
||
}
|
||
|
||
public bool DoUndo()
|
||
{
|
||
bool result = m_undoBuffer.DoUndo(this);
|
||
if (result) evtUndo();
|
||
return result;
|
||
}
|
||
|
||
public bool CanRedo()
|
||
{
|
||
bool result = m_undoBuffer.CanRedo;
|
||
return result;
|
||
}
|
||
|
||
public bool DoRedo()
|
||
{
|
||
bool result = m_undoBuffer.DoRedo(this);
|
||
ClearSelectedObjects();
|
||
if (result) evtRedo();
|
||
return result;
|
||
}
|
||
|
||
#region ISerialization function
|
||
public void Save(XmlWriter wr)
|
||
{
|
||
try {
|
||
#region 2.Drawing Objects¿¡ ´ëÇÑ µ¥ÀÌÅÍ ·Îµù
|
||
wr.WriteStartElement("DrawingObjects");
|
||
(m_backgroundLayer as BackgroundLayer).GetObjectData(wr);
|
||
(m_gridLayer as GridLayer).GetObjectData(wr);
|
||
foreach (ICanvasLayer layer in m_layers) {
|
||
if (layer is ISerialize) {
|
||
((ISerialize)layer).GetObjectData(wr);
|
||
}
|
||
}
|
||
wr.WriteEndElement();
|
||
|
||
m_undoBuffer.Dirty = false;
|
||
|
||
#endregion
|
||
} catch { }
|
||
}
|
||
|
||
public string Save()
|
||
{
|
||
string jsonString = string.Empty;
|
||
var options = new JsonSerializerOptions { WriteIndented = true };
|
||
try {
|
||
#region 2.Drawing Objects¿¡ ´ëÇÑ µ¥ÀÌÅÍ ·Îµù
|
||
|
||
//jsonString += JsonSerializer.Serialize(m_backgroundLayer, options);
|
||
//jsonString += JsonSerializer.Serialize(m_gridLayer, options);
|
||
foreach (ICanvasLayer layer in m_layers) {
|
||
if (layer is ISerialize) {
|
||
jsonString += ((ISerialize)layer).GetObjectData();
|
||
}
|
||
}
|
||
|
||
m_undoBuffer.Dirty = false;
|
||
|
||
#endregion
|
||
} catch { }
|
||
|
||
return jsonString;
|
||
}
|
||
|
||
public bool Load(XmlElement root)
|
||
{
|
||
try {
|
||
foreach (XmlElement node in root.ChildNodes) {
|
||
#region 2.Drawing Objects¿¡ ´ëÇÑ µ¥ÀÌÅÍ ·Îµù
|
||
ActiveLayer = null;
|
||
m_layers.Clear();
|
||
m_undoBuffer.Clear();
|
||
m_undoBuffer.Dirty = false;
|
||
|
||
foreach (XmlElement subNode in node.ChildNodes) {
|
||
if (subNode.Name == "backgroundlayer") {
|
||
Common.XmlUtil.ParseProperties(subNode, m_backgroundLayer);
|
||
continue;
|
||
}
|
||
if (subNode.Name == "gridlayer") {
|
||
Common.XmlUtil.ParseProperties(subNode, m_gridLayer);
|
||
continue;
|
||
}
|
||
if (subNode.Name == "layer") {
|
||
DrawingLayer l = DrawingLayer.NewLayer(subNode as XmlElement);
|
||
m_layers.Add(l);
|
||
}
|
||
if (subNode.Name == "property") {
|
||
Common.XmlUtil.ParseProperty(subNode, this);
|
||
}
|
||
}
|
||
if (m_layers.Count == UInt16.MinValue) //¸¸¾à SerializeÇÑ ·¹À̾îÀÇ µ¥ÀÌÅÍ°¡ ¾øÀ» °æ¿ì¿¡´Â default layerÀÇ »ý¼º.
|
||
{
|
||
DefaultLayer();
|
||
}
|
||
#endregion
|
||
}
|
||
|
||
return true;
|
||
} catch (Exception e) {
|
||
DefaultLayer();
|
||
Console.WriteLine("Load exception - {0}", e.Message);
|
||
}
|
||
|
||
return false;
|
||
}
|
||
#endregion
|
||
|
||
#region Group/Ungorup ±â´É
|
||
public void GroupObjects()
|
||
{
|
||
Group obj = (Group)CreateObject("Group");
|
||
List<IDrawObject> rearrangeObjects = RearrangeObjects(SelectedObjects);
|
||
obj.IncludeObjects(rearrangeObjects);
|
||
DeleteObjects(SelectedObjects, false);
|
||
ClearSelectedObjects();
|
||
AddObject(ActiveLayer, obj);
|
||
}
|
||
|
||
private List<IDrawObject> RearrangeObjects(List<IDrawObject> objects)
|
||
{
|
||
for (int i = 0; i < objects.Count - 1; i++) {
|
||
for (int j = i + 1; j < objects.Count; j++) {
|
||
if (objects[i].No > objects[j].No) {
|
||
IDrawObject obj = objects[i]; objects[i] = objects[j]; objects[j] = obj;
|
||
}
|
||
}
|
||
}
|
||
|
||
return objects;
|
||
}
|
||
|
||
public void UngroupObjects()
|
||
{
|
||
List<IDrawObject> releaseObjects = new List<IDrawObject>();
|
||
|
||
foreach (IDrawObject obj in SelectedObjects) {
|
||
if (obj is Group)//±×·ìÀÎ °æ¿ì¿¡¸¸ ungroup ÀÛ¾÷ ÁøÇà
|
||
{
|
||
foreach (IDrawObject subObj in ((Group)obj).SubObjects) {
|
||
releaseObjects.Add(subObj.Clone());
|
||
}
|
||
|
||
DeleteObjects(new List<IDrawObject> { obj }, false);
|
||
}
|
||
}
|
||
|
||
foreach (IDrawObject obj in releaseObjects) {
|
||
AddObject(ActiveLayer, obj);
|
||
}
|
||
}
|
||
#endregion
|
||
|
||
#region 1.¿ÜºÎ¿¡¼ CanvasÀÇ °´Ã¼¸¦ °ü¸®ÇÏ´Â ÇÔ¼ö
|
||
/// <summary>
|
||
/// »õ·Î¿î °´Ã¼¸¦ »ý¼ºÇÏ´Â ÇÔ¼ö(Canvas¿¡¼ »ý¼ºÇÏ´Â °ÍÀÌ ¾Æ´Ï¶ó, ¿ÜºÎ¿¡¼ »ý¼ºÇÒ ¶§ ½ÇÇà)
|
||
/// </summary>
|
||
///
|
||
public IDrawObject AddObject(AddObjectParam param)
|
||
{
|
||
IDrawObject drawObj = null;
|
||
|
||
switch (param.ObjectType) {
|
||
case "Line":
|
||
drawObj = CreateObject(param.ObjectType, param.Point1, null);
|
||
((LineEdit)drawObj).P2 = param.Point2;
|
||
((LineEdit)drawObj).Color = param.Color;
|
||
AddObject(ActiveLayer, drawObj, false);
|
||
break;
|
||
|
||
case "Dot":
|
||
drawObj = CreateObject(param.ObjectType, param.Point1, null);
|
||
((Dot)drawObj).Color = param.Color;
|
||
AddObject(ActiveLayer, drawObj, false);
|
||
break;
|
||
|
||
case "ArcCR":
|
||
drawObj = CreateObject(param.ObjectType, param.Center, null);
|
||
((Arc)drawObj).StartAngle = param.StartAngle;
|
||
((Arc)drawObj).EndAngle = param.EndAngle;
|
||
((Arc)drawObj).Radius = param.MajorRadius;
|
||
((Arc)drawObj).Color = param.Color;
|
||
((Arc)drawObj).Rotate(param.RotateAngle, param.Center);
|
||
AddObject(ActiveLayer, drawObj, false);
|
||
break;
|
||
|
||
case "Spline":
|
||
drawObj = CreateObject(param.ObjectType, param.Point1, null);
|
||
((Dot)drawObj).Color = param.Color;
|
||
AddObject(ActiveLayer, drawObj, false);
|
||
break;
|
||
|
||
case "SnowMan":
|
||
drawObj = CreateObject(param.ObjectType, param.Point1, null);
|
||
((SnowMan)drawObj).P2 = param.Point2;
|
||
((SnowMan)drawObj).Color = param.Color;
|
||
AddObject(ActiveLayer, drawObj, false);
|
||
break;
|
||
|
||
case "Group":
|
||
drawObj = CreateObject(param.ObjectType, param.Point1, null);
|
||
((Group)drawObj).Color = param.Color;
|
||
AddObject(ActiveLayer, drawObj, false);
|
||
break;
|
||
|
||
case "Rectangle":
|
||
drawObj = CreateObject(param.ObjectType, param.Point1, null);
|
||
((RectangleTool)drawObj).Color = param.Color;
|
||
((RectangleTool)drawObj).DrawBound(param.Point1, param.Point2);
|
||
AddObject(ActiveLayer, drawObj, false);
|
||
break;
|
||
|
||
case "Roi":
|
||
drawObj = CreateObject(param.ObjectType, param.Point1, null);
|
||
((RoiTool)drawObj).Color = param.Color;
|
||
((RoiTool)drawObj).Locked = true;
|
||
((RoiTool)drawObj).DrawBound(param.Point1, param.Point2);
|
||
AddObject(ActiveLayer, drawObj, false);
|
||
break;
|
||
|
||
case "ZigZag":
|
||
drawObj = CreateObject(param.ObjectType, param.Point1, null);
|
||
((ZigZag)drawObj).P2 = param.Point2;
|
||
((ZigZag)drawObj).Color = param.Color;
|
||
AddObject(ActiveLayer, drawObj, false);
|
||
break;
|
||
|
||
case "PolyLine":
|
||
drawObj = CreateObject(param.ObjectType, param.Point1, null);
|
||
((LineEdit)drawObj).P2 = param.Point2;
|
||
((LineEdit)drawObj).Color = param.Color;
|
||
AddObject(ActiveLayer, drawObj, false);
|
||
break;
|
||
|
||
case "Ellipse":
|
||
drawObj = CreateObject(param.ObjectType, param.Center, null);
|
||
((EllipseTool)drawObj).Color = param.Color;
|
||
((EllipseTool)drawObj).DrawBound(param.Point1, param.Point2);
|
||
((EllipseTool)drawObj).Rotate(param.RotateAngle, param.Center);
|
||
((EllipseTool)drawObj).StartAngle = param.StartAngle;
|
||
((EllipseTool)drawObj).EndAngle = param.EndAngle;
|
||
AddObject(ActiveLayer, drawObj, false);
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
return drawObj;
|
||
}
|
||
|
||
public IDrawObject AddObject(string objectType, UnitPoint pt1, UnitPoint pt2, Color color)
|
||
{
|
||
IDrawObject drawObj = null;
|
||
|
||
switch (objectType) {
|
||
case "Line":
|
||
drawObj = CreateObject(objectType, pt1, null);
|
||
((LineEdit)drawObj).P2 = pt2;
|
||
((LineEdit)drawObj).Color = color;
|
||
AddObject(ActiveLayer, drawObj, false);
|
||
break;
|
||
|
||
case "Dot":
|
||
drawObj = CreateObject(objectType, pt1, null);
|
||
((Dot)drawObj).Color = color;
|
||
AddObject(ActiveLayer, drawObj, false);
|
||
break;
|
||
|
||
case "Arc":
|
||
drawObj = CreateObject(objectType, pt1, null);
|
||
((Arc)drawObj).Color = color;
|
||
AddObject(ActiveLayer, drawObj, false);
|
||
break;
|
||
|
||
case "Spline":
|
||
drawObj = CreateObject(objectType, pt1, null);
|
||
((Dot)drawObj).Color = color;
|
||
AddObject(ActiveLayer, drawObj, false);
|
||
break;
|
||
|
||
case "SnowMan":
|
||
drawObj = CreateObject(objectType, pt1, null);
|
||
((SnowMan)drawObj).P2 = pt2;
|
||
((SnowMan)drawObj).Color = color;
|
||
AddObject(ActiveLayer, drawObj, false);
|
||
break;
|
||
|
||
case "Group":
|
||
drawObj = CreateObject(objectType, pt1, null);
|
||
((Group)drawObj).Color = color;
|
||
AddObject(ActiveLayer, drawObj, false);
|
||
break;
|
||
|
||
case "Rectangle":
|
||
drawObj = CreateObject(objectType, pt1, null);
|
||
((RectangleTool)drawObj).Color = color;
|
||
((RectangleTool)drawObj).Locked = true;
|
||
((RectangleTool)drawObj).DrawBound(pt1, pt2);
|
||
AddObject(ActiveLayer, drawObj, false);
|
||
break;
|
||
|
||
case "Roi":
|
||
drawObj = CreateObject(objectType, pt1, null);
|
||
((RoiTool)drawObj).Color = color;
|
||
((RoiTool)drawObj).Locked = true;
|
||
((RoiTool)drawObj).DrawBound(pt1, pt2);
|
||
AddObject(ActiveLayer, drawObj, false);
|
||
break;
|
||
|
||
case "ZigZag":
|
||
drawObj = CreateObject(objectType, pt1, null);
|
||
((ZigZag)drawObj).P2 = pt2;
|
||
((ZigZag)drawObj).Color = color;
|
||
AddObject(ActiveLayer, drawObj, false);
|
||
break;
|
||
|
||
case "PolyLine":
|
||
drawObj = CreateObject(objectType, pt1, null);
|
||
((LineEdit)drawObj).P2 = pt2;
|
||
((LineEdit)drawObj).Color = color;
|
||
AddObject(ActiveLayer, drawObj, false);
|
||
break;
|
||
|
||
case "Ellipse":
|
||
drawObj = CreateObject(objectType, pt1, null);
|
||
((EllipseTool)drawObj).Color = color;
|
||
((EllipseTool)drawObj).Locked = true;
|
||
((EllipseTool)drawObj).DrawBound(pt1, pt2);
|
||
AddObject(ActiveLayer, drawObj, false);
|
||
break;
|
||
|
||
default:
|
||
break;
|
||
}
|
||
|
||
return drawObj;
|
||
}
|
||
|
||
/// <summary>
|
||
/// ¼±ÅÃµÈ °´Ã¼¸¦ Áö¿ì´Â ÇÔ¼ö(Canvas¿¡¼ Áö¿ì´Â °ÍÀÌ ¾Æ´Ï¶ó, ¿ÜºÎ¿¡¼ Áö¿ï ¶§ ½ÇÇà)
|
||
/// </summary>
|
||
public void DeleteAllObjects()
|
||
{
|
||
((DrawingLayer)ActiveLayer).DeleteObjects(((DrawingLayer)ActiveLayer).Objects);
|
||
}
|
||
|
||
/// <summary>
|
||
/// °´Ã¼¸¦ ¼±ÅÃÇÏ´Â ÇÔ¼ö(Canvas¿¡¼ ¼±ÅÃÇÏ´Â °ÍÀÌ ¾Æ´Ï¶ó, ¿ÜºÎ¿¡¼ ¼±ÅÃÇÒ ¶§ ½ÇÇà)
|
||
/// </summary>
|
||
public void SelectObject(int index, bool addMode)
|
||
{
|
||
if (addMode == false) ClearSelectedObjects();
|
||
AddSelectedObject(((DrawingLayer)ActiveLayer).Objects[index]);
|
||
}
|
||
#endregion
|
||
|
||
#region 2. Çʵå À̹ÌÁö ±â´É
|
||
SizeF m_canvasImageSize = new SizeF(0, 0);
|
||
public SizeF CanvasImageSize {
|
||
get { return m_canvasImageSize; }
|
||
set { m_canvasImageSize = value; }
|
||
}
|
||
|
||
bool m_canvasImageEnable = false;
|
||
public bool CanvasImageEnable {
|
||
get { lock (this) { return m_canvasImageEnable; } }
|
||
set { lock (this) { m_canvasImageEnable = value; } }
|
||
}
|
||
|
||
Bitmap m_canvasImage = null;
|
||
public Bitmap CanvasImage {
|
||
get { lock (this) { return m_canvasImage; } }
|
||
set { lock (this) { m_canvasImage = value; } }
|
||
}
|
||
#endregion
|
||
#region 3. Canvas »ö»ó ¹× °ÝÀÚ »ç¿ë À¯¹« ¿É¼Ç
|
||
bool m_canvasColorEnable = false;
|
||
public bool EnableCanvasColor {
|
||
get { lock (this) { return m_canvasColorEnable; } }
|
||
set { lock (this) { m_canvasColorEnable = value; } }
|
||
}
|
||
|
||
bool m_canvasGridEnable = false;
|
||
public bool EnableCanvasGrid {
|
||
get { lock (this) { return m_canvasGridEnable; } }
|
||
set { lock (this) { m_canvasGridEnable = value; } }
|
||
}
|
||
#endregion
|
||
#endregion
|
||
|
||
public void Clone(DataModel org)
|
||
{
|
||
lock (this) {
|
||
CanvasImage = org.CanvasImage;
|
||
CenterPoint = org.CenterPoint;
|
||
CanvasImageEnable = org.CanvasImageEnable;
|
||
CanvasImageSize = org.CanvasImageSize;
|
||
ScaleToFit = org.ScaleToFit;
|
||
Zoom = org.Zoom;
|
||
EnableCanvasColor = org.EnableCanvasColor;
|
||
EnableCanvasGrid = org.EnableCanvasGrid;
|
||
|
||
var thisDrawing = ActiveLayer as DrawingLayer;
|
||
var orgDrawing = org.ActiveLayer as DrawingLayer;
|
||
thisDrawing.Copy(orgDrawing, true);
|
||
|
||
var thisGrid = GridLayer as GridLayer;
|
||
var orgGrid = org.GridLayer as GridLayer;
|
||
thisGrid.Copy(orgGrid);
|
||
|
||
var thisBackground = BackgroundLayer as BackgroundLayer;
|
||
var orgBackground = org.BackgroundLayer as BackgroundLayer;
|
||
thisBackground.Copy(orgBackground);
|
||
}
|
||
}
|
||
}
|
||
}
|