toan / Robofork

Compare View

Commits (4)

93c4a5599 RM2101 commit source Browse Code »
1

toan
2017-03-29 01:22:11 +0900
56b242f57 Revert "RM2101 commit source" ... Browse Code »

This reverts commit 93c4a5599481ec075c375382e2163ca42f1f58ac.

toan
2017-03-29 01:24:49 +0900
358693b7f Merge branch 'master' of http://timesfun.net/toan/robofork Browse Code »

toan
2017-03-29 01:28:02 +0900
e658bdccd RM2101 comit source Browse Code »

toan
2017-03-29 01:32:03 +0900

Changes

Showing 2 changed files Inline Diff

sources/RoboforkApp/Controls/DesignerCanvas.cs
sources/RoboforkApp/RoboforkMenuView.xaml.cs

sources/RoboforkApp/Controls/DesignerCanvas.cs

1	using RoboforkApp.DataModel;	1	using RoboforkApp.DataModel;
2	//using RoboforkApp.Entities;	2	//using RoboforkApp.Entities;
3	//using RoboforkApp.Services;	3	//using RoboforkApp.Services;
4	using System;	4	using System;
5	using System.Collections.Generic;	5	using System.Collections.Generic;
6	using System.Linq;	6	using System.Linq;
7	using System.Windows;	7	using System.Windows;
8	using System.Windows.Controls;	8	using System.Windows.Controls;
9	using System.Windows.Documents;	9	using System.Windows.Documents;
10	using System.Windows.Input;	10	using System.Windows.Input;
11	using System.Windows.Markup;	11	using System.Windows.Markup;
12	using System.Windows.Media;	12	using System.Windows.Media;
13	using System.Windows.Shapes;	13	using System.Windows.Shapes;
14	using System.Xml;	14	using System.Xml;
15	using System.Data;	15	using System.Data;
16	using RoboforkApp.View;	16	using RoboforkApp.View;
17	using RoboforkApp.Services;	17	using RoboforkApp.Services;
18	using RoboforkApp.Entities;	18	using RoboforkApp.Entities;
19		19
20	namespace RoboforkApp	20	namespace RoboforkApp
21	{	21	{
22	public class DesignerCanvas : Canvas	22	public class DesignerCanvas : Canvas
23	{	23	{
24	const double RADIUS_NODE = 25d; //8d;	24	const double RADIUS_NODE = 25d; //8d;
25	const double RADIUS_CURVER_LINE = 130d;	25	const double RADIUS_CURVER_LINE = 130d;
26	const double DISTANCE_AUTO_NODES = 100d;	26	const double DISTANCE_AUTO_NODES = 100d;
27	const double DISTANCE_START_NODES = 30d;	27	const double DISTANCE_START_NODES = 30d;
28	const double DISTANCE_END_NODES = 30d;	28	const double DISTANCE_END_NODES = 30d;
29	const double DISTANCE_FREE_NODES = 40d;	29	const double DISTANCE_FREE_NODES = 40d;
30	const double STROKE_ROOT_LINE = 6d;	30	const double STROKE_ROOT_LINE = 6d;
31	const double STROKE_LINE = 4d;	31	const double STROKE_LINE = 4d;
32	const double STROKE_NODE = 1d;	32	const double STROKE_NODE = 1d;
33	const double DISTANCE_RATIO = 100;	33	const double DISTANCE_RATIO = 100;
34		34
35	const double UCNODE_SETLEFT = 17;	35	const double UCNODE_SETLEFT = 17;
36	const double UCNODE_SETTOP = 17;	36	const double UCNODE_SETTOP = 17;
37	const double UCNODE_WIDTH = 34;	37	const double UCNODE_WIDTH = 34;
38	const double UCNODE_HEIGHT = 34;	38	const double UCNODE_HEIGHT = 34;
39		39
40	const double UCSCHEDULENODE_SETLEFT = 12;	40	const double UCSCHEDULENODE_SETLEFT = 12;
41	const double UCSCHEDULENODE_SETTOP = 12;	41	const double UCSCHEDULENODE_SETTOP = 12;
42	const double UCSCHEDULENODE_WIDTH = 24;	42	const double UCSCHEDULENODE_WIDTH = 24;
43	const double UCSCHEDULENODE_HEIGHT = 24;	43	const double UCSCHEDULENODE_HEIGHT = 24;
44		44
45	private List<Rectangle> shapeList = new List<Rectangle>();	45	private List<Rectangle> shapeList = new List<Rectangle>();
46	private TextBlock shapePosIndicator;	46	private TextBlock shapePosIndicator;
47	private TextBlock shapeSizeIndicator;	47	private TextBlock shapeSizeIndicator;
48	private int currentLine;	48	private int currentLine;
49	private ucStartEndButton _startPoint;	49	private ucStartEndButton _startPoint;
50	private ucNode _ucNodeFree;	50	private ucNode _ucNodeFree;
51	private ucStartEndButton _goalPoint;	51	private ucStartEndButton _goalPoint;
52	private ucDisplayCoordinate _displayAxiPosition;	52	private ucDisplayCoordinate _displayAxiPosition;
53		53
54	// Add variable for draw route	54	// Add variable for draw route
55	public Path pLine = new Path();	55	public Path pLine = new Path();
56	public Path pRootLine = new Path();	56	public Path pRootLine = new Path();
57	public Path pCurverLine = new Path();	57	public Path pCurverLine = new Path();
58	public Path pRedNode = new Path();	58	public Path pRedNode = new Path();
59	public Path pYellowNode = new Path();	59	public Path pYellowNode = new Path();
60	public GeometryGroup gGrpLine = new GeometryGroup();	60	public GeometryGroup gGrpLine = new GeometryGroup();
61	public GeometryGroup gGrpRootLine = new GeometryGroup();	61	public GeometryGroup gGrpRootLine = new GeometryGroup();
62	public GeometryGroup gGrpCurverLine = new GeometryGroup();	62	public GeometryGroup gGrpCurverLine = new GeometryGroup();
63	public GeometryGroup gGrpRedNode = new GeometryGroup();	63	public GeometryGroup gGrpRedNode = new GeometryGroup();
64	public GeometryGroup gGrpYellowNode = new GeometryGroup();	64	public GeometryGroup gGrpYellowNode = new GeometryGroup();
65	public int currentShape;	65	public int currentShape;
66	public static bool isStartDrawRoute = false;	66	public static bool isStartDrawRoute = false;
67	public static bool isGoalDrawRoute = false;	67	public static bool isGoalDrawRoute = false;
68		68
69	public static bool readMapFan = true;	69	public static bool readMapFan = true;
70		70
71	public static double CanvasScheduleWidth = 0;	71	public static double CanvasScheduleWidth = 0;
72	public static double CanvasScheduleHeight = 0;	72	public static double CanvasScheduleHeight = 0;
73	public const double NodeSchedule_X = 50;	73	public const double NodeSchedule_X = 50;
74		74
75	public double PointMapStart_X = 127.85783428698775;	75	public double PointMapStart_X = 127.85783428698775;
76	public double PointMapStart_Y = 26.336094486866543;	76	public double PointMapStart_Y = 26.336094486866543;
77		77
78	public double PointMapEnd_X = 128.85783428698775;	78	public double PointMapEnd_X = 128.85783428698775;
79	public double PointMapEnd_Y = 27.336094486866543;	79	public double PointMapEnd_Y = 27.336094486866543;
80		80
81	const double DISTANCEMAPDISPLAY = 1000;	81	const double DISTANCEMAPDISPLAY = 1000;
82		82
83	public double Scale_X = 0;	83	public double Scale_X = 0;
84	public double Scale_Y = 0;	84	public double Scale_Y = 0;
85		85
86	public struct NodeInfo	86	public struct NodeInfo
87	{	87	{
88	public double X;	88	public double X;
89	public double Y;	89	public double Y;
90	public String Mode1;	90	public String Mode1;
91	public String Mode2;	91	public String Mode2;
92	public String Mode3;	92	public String Mode3;
93	}	93	}
94	List<NodeInfo> NodeInfo_List = new List<NodeInfo>();	94	List<NodeInfo> NodeInfo_List = new List<NodeInfo>();
95		95
96	// Add variable for Set Schedule	96	// Add variable for Set Schedule
97	public Path pScheduleNode = new Path();	97	public Path pScheduleNode = new Path();
98	public Path pScheduleLine = new Path();	98	public Path pScheduleLine = new Path();
99	public GeometryGroup gGrpScheduleNode = new GeometryGroup();	99	public GeometryGroup gGrpScheduleNode = new GeometryGroup();
100	public GeometryGroup gGrpScheduleLine = new GeometryGroup();	100	public GeometryGroup gGrpScheduleLine = new GeometryGroup();
101		101
102	public static bool EditNodeFlag = false;	102	public static bool EditNodeFlag = false;
103	public static bool DragDeltaFlag = false;	103	public static bool DragDeltaFlag = false;
104	public static bool LoadDBFlag = false;	104	public static bool LoadDBFlag = false;
105		105
106	//Add variable for Vehicle Item click	106	//Add variable for Vehicle Item click
107	public string VehicleItem = "FK_15";	107	public string VehicleItem = "FK_15";
108		108
109	public int VehicleIndex = 0;	109	public int VehicleIndex = 0;
110	public string ColorNode_Add = "Blue";	110	public string ColorNode_Add = "Blue";
111	public string ColorNode_Insert = "Brown";	111	public string ColorNode_Insert = "Brown";
112		112
113	public int ProjectIndex = 0;	113	public int ProjectIndex = 0;
114	public string ProjectItem = "ProjectAAA";	114	public string ProjectItem = "ProjectAAA";
115	public ProjectModel ProjectModel = new ProjectModel();	115	public ProjectModel ProjectModel = new ProjectModel();
116		116
117	//2017/03/04 NAM ADD START	117	//2017/03/04 NAM ADD START
118	public static bool isDrawingNode = false;	118	public static bool isDrawingNode = false;
119	public static bool isDragNode = false;	119	public static bool isDragNode = false;
120	public Path pNewLine = new Path();	120	public Path pNewLine = new Path();
121	public GeometryGroup gGrpNewLine = new GeometryGroup();	121	public GeometryGroup gGrpNewLine = new GeometryGroup();
122		122
123	public struct NewNodeInfo	123	public struct NewNodeInfo
124	{	124	{
125	public double X;	125	public double X;
126	public double Y;	126	public double Y;
127	public String Mode;	127	public String Mode;
128	}	128	}
129	List<NewNodeInfo> NewNodeInfo_List = new List<NewNodeInfo>();	129	List<NewNodeInfo> NewNodeInfo_List = new List<NewNodeInfo>();
130		130
131	//List Node's Info	131	//List Node's Info
132	List<Node_tmp> Lst_Node_tmp = new List<Node_tmp>();	132	List<Node_tmp> Lst_Node_tmp = new List<Node_tmp>();
133		133
134		134
135		135
136		136
137	List<TextBlock> NodeNo = new List<TextBlock>();	137	List<TextBlock> NodeNo = new List<TextBlock>();
138	List<ucNode> ucNode_Lst = new List<ucNode>();	138	List<ucNode> ucNode_Lst = new List<ucNode>();
139	public List<ucNode> ucScheduleNode_Lst = new List<ucNode>();	139	public List<ucNode> ucScheduleNode_Lst = new List<ucNode>();
140	int stt = 1;	140	int stt = 1;
141	//2017/03/04 NAM ADD END	141	//2017/03/04 NAM ADD END
142	public struct ListIndexNodeInsert	142	public struct ListIndexNodeInsert
143	{	143	{
144	public double X;	144	public double X;
145	public double Y;	145	public double Y;
146	}	146	}
147	List<ListIndexNodeInsert> IndexNodeInsert_List = new List<ListIndexNodeInsert>();	147	List<ListIndexNodeInsert> IndexNodeInsert_List = new List<ListIndexNodeInsert>();
148		148
149	public struct ListNameNode	149	public struct ListNameNode
150	{	150	{
151	public double X;	151	public double X;
152	public double Y;	152	public double Y;
153	public string nameNode;	153	public string nameNode;
154	}	154	}
155	List<ListNameNode> NameNode_List = new List<ListNameNode>();	155	List<ListNameNode> NameNode_List = new List<ListNameNode>();
156		156
157		157
158	public ScheduleCanvas scheduleCanvas = new ScheduleCanvas();	158	public ScheduleCanvas scheduleCanvas = new ScheduleCanvas();
159		159
160	// Add variable for Set Auto Nodes	160	// Add variable for Set Auto Nodes
161	public Path pBlueNode = new Path();	161	public Path pBlueNode = new Path();
162	private GeometryGroup gGrpBlueNode = new GeometryGroup();	162	private GeometryGroup gGrpBlueNode = new GeometryGroup();
163		163
164	// Add variable for Actual Nodes	164	// Add variable for Actual Nodes
165	public Path pActualNode = new Path();	165	public Path pActualNode = new Path();
166	private GeometryGroup gGrpActualNode = new GeometryGroup();	166	private GeometryGroup gGrpActualNode = new GeometryGroup();
167		167
168	// Add variable for Set Free Nodes	168	// Add variable for Set Free Nodes
169	public Path pFreeNode = new Path();	169	public Path pFreeNode = new Path();
170	//private GeometryGroup gGrpFreeNode = new GeometryGroup();	170	//private GeometryGroup gGrpFreeNode = new GeometryGroup();
171		171
172	// The part of the rectangle the mouse is over.	172	// The part of the rectangle the mouse is over.
173	private enum HitType	173	private enum HitType
174	{	174	{
175	None, Body, UL, UR, LR, LL, L, R, T, B	175	None, Body, UL, UR, LR, LL, L, R, T, B
176	};	176	};
177	public enum OperationState	177	public enum OperationState
178	{	178	{
179	None, DrawObstract, DrawRoute, DrawSetFreeNode, EditNode, NewDrawSetFreeNode	179	None, DrawObstract, DrawRoute, DrawSetFreeNode, EditNode, NewDrawSetFreeNode
180	};	180	};
181	public enum MouseState	181	public enum MouseState
182	{	182	{
183	None, Draw, Drag,	183	None, Draw, Drag,
184	}	184	}
185	public OperationState Operation = OperationState.None;	185	public OperationState Operation = OperationState.None;
186	public MouseState mouseState = MouseState.None;	186	public MouseState mouseState = MouseState.None;
187		187
188	// The draw start point.	188	// The draw start point.
189	private Point StartDrawPoint;	189	private Point StartDrawPoint;
190		190
191	// The drag's last point.	191	// The drag's last point.
192	private Point LastPoint;	192	private Point LastPoint;
193		193
194	// The part of the rectangle under the mouse.	194	// The part of the rectangle under the mouse.
195	HitType MouseHitType = HitType.None;	195	HitType MouseHitType = HitType.None;
196		196
197	public void Init()	197	public void Init()
198	{	198	{
199	if (shapePosIndicator == null)	199	if (shapePosIndicator == null)
200	{	200	{
201	shapePosIndicator = new TextBlock()	201	shapePosIndicator = new TextBlock()
202	{	202	{
203	Foreground = Brushes.Black,	203	Foreground = Brushes.Black,
204	Background = Brushes.Transparent,	204	Background = Brushes.Transparent,
205	FontSize = 20,	205	FontSize = 20,
206	};	206	};
207	}	207	}
208	if (shapeSizeIndicator == null)	208	if (shapeSizeIndicator == null)
209	{	209	{
210	shapeSizeIndicator = new TextBlock()	210	shapeSizeIndicator = new TextBlock()
211	{	211	{
212	Foreground = Brushes.Black,	212	Foreground = Brushes.Black,
213	Background = Brushes.Transparent,	213	Background = Brushes.Transparent,
214	FontSize = 20,	214	FontSize = 20,
215	};	215	};
216	}	216	}
217	}	217	}
218		218
219	// Return a HitType value to indicate what is at the point.	219	// Return a HitType value to indicate what is at the point.
220	private HitType SetHitType(Point point)	220	private HitType SetHitType(Point point)
221	{	221	{
222	if (shapeList.Count == 0)	222	if (shapeList.Count == 0)
223	{	223	{
224	currentShape = 0;	224	currentShape = 0;
225	return HitType.None;	225	return HitType.None;
226	}	226	}
227	for (int i = 0; i < shapeList.Count; i++)	227	for (int i = 0; i < shapeList.Count; i++)
228	{	228	{
229	Rectangle rect = shapeList[i];	229	Rectangle rect = shapeList[i];
230	double left = Canvas.GetLeft(rect);	230	double left = Canvas.GetLeft(rect);
231	double top = Canvas.GetTop(rect);	231	double top = Canvas.GetTop(rect);
232	double right = left + rect.Width;	232	double right = left + rect.Width;
233	double bottom = top + rect.Height;	233	double bottom = top + rect.Height;
234	if (point.X < left) continue;	234	if (point.X < left) continue;
235	if (point.X > right) continue;	235	if (point.X > right) continue;
236	if (point.Y < top) continue;	236	if (point.Y < top) continue;
237	if (point.Y > bottom) continue;	237	if (point.Y > bottom) continue;
238	currentShape = i;	238	currentShape = i;
239		239
240	const double GAP = 10;	240	const double GAP = 10;
241	if (point.X - left < GAP)	241	if (point.X - left < GAP)
242	{	242	{
243	// Left edge.	243	// Left edge.
244	if (point.Y - top < GAP) return HitType.UL;	244	if (point.Y - top < GAP) return HitType.UL;
245	if (bottom - point.Y < GAP) return HitType.LL;	245	if (bottom - point.Y < GAP) return HitType.LL;
246	return HitType.L;	246	return HitType.L;
247	}	247	}
248	if (right - point.X < GAP)	248	if (right - point.X < GAP)
249	{	249	{
250	// Right edge.	250	// Right edge.
251	if (point.Y - top < GAP) return HitType.UR;	251	if (point.Y - top < GAP) return HitType.UR;
252	if (bottom - point.Y < GAP) return HitType.LR;	252	if (bottom - point.Y < GAP) return HitType.LR;
253	return HitType.R;	253	return HitType.R;
254	}	254	}
255	if (point.Y - top < GAP) return HitType.T;	255	if (point.Y - top < GAP) return HitType.T;
256	if (bottom - point.Y < GAP) return HitType.B;	256	if (bottom - point.Y < GAP) return HitType.B;
257	return HitType.Body;	257	return HitType.Body;
258	}	258	}
259	currentShape = 0;	259	currentShape = 0;
260	return HitType.None;	260	return HitType.None;
261	}	261	}
262		262
263	// Set a mouse cursor appropriate for the current hit type.	263	// Set a mouse cursor appropriate for the current hit type.
264	private void SetMouseCursor()	264	private void SetMouseCursor()
265	{	265	{
266	// See what cursor we should display.	266	// See what cursor we should display.
267	Cursor desired_cursor = Cursors.Arrow;	267	Cursor desired_cursor = Cursors.Arrow;
268	switch (MouseHitType)	268	switch (MouseHitType)
269	{	269	{
270	case HitType.None:	270	case HitType.None:
271	desired_cursor = Cursors.Arrow;	271	desired_cursor = Cursors.Arrow;
272	break;	272	break;
273	case HitType.Body:	273	case HitType.Body:
274	desired_cursor = Cursors.ScrollAll;	274	desired_cursor = Cursors.ScrollAll;
275	break;	275	break;
276	case HitType.UL:	276	case HitType.UL:
277	case HitType.LR:	277	case HitType.LR:
278	desired_cursor = Cursors.SizeNWSE;	278	desired_cursor = Cursors.SizeNWSE;
279	break;	279	break;
280	case HitType.LL:	280	case HitType.LL:
281	case HitType.UR:	281	case HitType.UR:
282	desired_cursor = Cursors.SizeNESW;	282	desired_cursor = Cursors.SizeNESW;
283	break;	283	break;
284	case HitType.T:	284	case HitType.T:
285	case HitType.B:	285	case HitType.B:
286	desired_cursor = Cursors.SizeNS;	286	desired_cursor = Cursors.SizeNS;
287	break;	287	break;
288	case HitType.L:	288	case HitType.L:
289	case HitType.R:	289	case HitType.R:
290	desired_cursor = Cursors.SizeWE;	290	desired_cursor = Cursors.SizeWE;
291	break;	291	break;
292	}	292	}
293		293
294	// Display the desired cursor.	294	// Display the desired cursor.
295	if (Cursor != desired_cursor) Cursor = desired_cursor;	295	if (Cursor != desired_cursor) Cursor = desired_cursor;
296	}	296	}
297		297
298	// constance	298	// constance
299	int indicatorAligment = 2;	299	int indicatorAligment = 2;
300		300
301	/*	301	/*
302	private Point? dragStartPoint = null;	302	private Point? dragStartPoint = null;
303		303
304	*/	304	*/
305	public IEnumerable<DesignerItem> SelectedItems	305	public IEnumerable<DesignerItem> SelectedItems
306	{	306	{
307	get	307	get
308	{	308	{
309	var selectedItems = from item in this.Children.OfType<DesignerItem>()	309	var selectedItems = from item in this.Children.OfType<DesignerItem>()
310	where item.IsSelected == true	310	where item.IsSelected == true
311	select item;	311	select item;
312		312
313	return selectedItems;	313	return selectedItems;
314	}	314	}
315	}	315	}
316		316
317	public void DeselectAll()	317	public void DeselectAll()
318	{	318	{
319	/*	319	/*
320	foreach (DesignerItem item in this.SelectedItems)	320	foreach (DesignerItem item in this.SelectedItems)
321	{	321	{
322	item.IsSelected = false;	322	item.IsSelected = false;
323	}*/	323	}*/
324	}	324	}
325		325
326	protected override void OnMouseDown(MouseButtonEventArgs e)	326	protected override void OnMouseDown(MouseButtonEventArgs e)
327	{	327	{
328	base.OnMouseDown(e);	328	base.OnMouseDown(e);
329		329
330	MouseHitType = SetHitType(Mouse.GetPosition(this));	330	MouseHitType = SetHitType(Mouse.GetPosition(this));
331	SetMouseCursor();	331	SetMouseCursor();
332		332
333	if (Operation == OperationState.DrawRoute && isStartDrawRoute)	333	if (Operation == OperationState.DrawRoute && isStartDrawRoute)
334	{	334	{
335	if (isGoalDrawRoute)	335	if (isGoalDrawRoute)
336	{	336	{
337	return;	337	return;
338	}	338	}
339		339
340	// Check state draw	340	// Check state draw
341	if (MouseHitType == HitType.None)	341	if (MouseHitType == HitType.None)
342	{	342	{
343	if (gGrpLine.Children.Count == 1)	343	if (gGrpLine.Children.Count == 1)
344	{	344	{
345	LineGeometry lineGeometry = (LineGeometry)gGrpLine.Children[0];	345	LineGeometry lineGeometry = (LineGeometry)gGrpLine.Children[0];
346	lineGeometry.EndPoint = LastPoint;	346	lineGeometry.EndPoint = LastPoint;
347		347
348	// Check end route	348	// Check end route
349	if (IsEndRoute(_goalPoint, lineGeometry))	349	if (IsEndRoute(_goalPoint, lineGeometry))
350	{	350	{
351	isGoalDrawRoute = true;	351	isGoalDrawRoute = true;
352	ProcessEndRoute();	352	ProcessEndRoute();
353	return;	353	return;
354	}	354	}
355	}	355	}
356	else if (IsCurverNode((LineGeometry)gGrpLine.Children[currentLine - 1]	356	else if (IsCurverNode((LineGeometry)gGrpLine.Children[currentLine - 1]
357	, (LineGeometry)gGrpLine.Children[currentLine]))	357	, (LineGeometry)gGrpLine.Children[currentLine]))
358	{	358	{
359	// Set end point to finish draw line	359	// Set end point to finish draw line
360	LineGeometry lineGeometry = (LineGeometry)gGrpLine.Children[currentLine];	360	LineGeometry lineGeometry = (LineGeometry)gGrpLine.Children[currentLine];
361	lineGeometry.EndPoint = LastPoint;	361	lineGeometry.EndPoint = LastPoint;
362		362
363	// Add node to curver postion	363	// Add node to curver postion
364	AddNode(lineGeometry.StartPoint, gGrpRedNode);	364	AddNode(lineGeometry.StartPoint, gGrpRedNode);
365		365
366	// Check end route	366	// Check end route
367	if (IsEndRoute(_goalPoint, lineGeometry))	367	if (IsEndRoute(_goalPoint, lineGeometry))
368	{	368	{
369	isGoalDrawRoute = true;	369	isGoalDrawRoute = true;
370	ProcessEndRoute();	370	ProcessEndRoute();
371	return;	371	return;
372	}	372	}
373	}	373	}
374	else	374	else
375	{	375	{
376	// Remove current line	376	// Remove current line
377	gGrpLine.Children.RemoveAt(currentLine);	377	gGrpLine.Children.RemoveAt(currentLine);
378		378
379	// Set end point to finish draw line	379	// Set end point to finish draw line
380	LineGeometry lineGeometry = (LineGeometry)gGrpLine.Children[currentLine - 1];	380	LineGeometry lineGeometry = (LineGeometry)gGrpLine.Children[currentLine - 1];
381	lineGeometry.EndPoint = LastPoint;	381	lineGeometry.EndPoint = LastPoint;
382		382
383	// Check end route	383	// Check end route
384	if (IsEndRoute(_goalPoint, lineGeometry))	384	if (IsEndRoute(_goalPoint, lineGeometry))
385	{	385	{
386	isGoalDrawRoute = true;	386	isGoalDrawRoute = true;
387	ProcessEndRoute();	387	ProcessEndRoute();
388	return;	388	return;
389	}	389	}
390	}	390	}
391		391
392	// Draw new line	392	// Draw new line
393	DrawLine(LastPoint, LastPoint, gGrpLine);	393	DrawLine(LastPoint, LastPoint, gGrpLine);
394	// Setting start point for new line	394	// Setting start point for new line
395	StartDrawPoint = LastPoint;	395	StartDrawPoint = LastPoint;
396		396
397	mouseState = MouseState.Draw;	397	mouseState = MouseState.Draw;
398	currentLine = gGrpLine.Children.Count - 1;	398	currentLine = gGrpLine.Children.Count - 1;
399	return;	399	return;
400	}	400	}
401	}	401	}
402	else if (Operation == OperationState.DrawSetFreeNode)	402	else if (Operation == OperationState.DrawSetFreeNode)
403	{	403	{
404	bool RightClick = false;	404	bool RightClick = false;
405	if (IsStopDrawRoute(e))	405	if (IsStopDrawRoute(e))
406	RightClick = true;	406	RightClick = true;
407		407
408	StartDrawPoint = e.MouseDevice.GetPosition(this);	408	StartDrawPoint = e.MouseDevice.GetPosition(this);
409		409
410	SetFreeNodes(StartDrawPoint, RightClick);	410	SetFreeNodes(StartDrawPoint, RightClick);
411	}	411	}
412		412
413	else if (Operation == OperationState.EditNode)	413	else if (Operation == OperationState.EditNode)
414	{	414	{
415	Point node_edited = e.MouseDevice.GetPosition(this);	415	Point node_edited = e.MouseDevice.GetPosition(this);
416		416
417	// start Edit Node Infor	417	// start Edit Node Infor
418	//EditNode(node_edited);	418	//EditNode(node_edited);
419		419
420	}	420	}
421	else if (Operation == OperationState.DrawObstract)	421	else if (Operation == OperationState.DrawObstract)
422	{	422	{
423	if (MouseHitType == HitType.None)	423	if (MouseHitType == HitType.None)
424	{	424	{
425	Rectangle shape = new Rectangle();	425	Rectangle shape = new Rectangle();
426	shape.Width = 1;	426	shape.Width = 1;
427	shape.Height = 1;	427	shape.Height = 1;
428	// Create a SolidColorBrush and use it to	428	// Create a SolidColorBrush and use it to
429	// paint the rectangle.	429	// paint the rectangle.
430	shape.Stroke = Brushes.Blue;	430	shape.Stroke = Brushes.Blue;
431	shape.StrokeThickness = 1;	431	shape.StrokeThickness = 1;
432	shape.Fill = new SolidColorBrush(Colors.LightCyan);	432	shape.Fill = new SolidColorBrush(Colors.LightCyan);
433	StartDrawPoint = e.MouseDevice.GetPosition(this);	433	StartDrawPoint = e.MouseDevice.GetPosition(this);
434	shape.SetValue(Canvas.LeftProperty, StartDrawPoint.X);	434	shape.SetValue(Canvas.LeftProperty, StartDrawPoint.X);
435	shape.SetValue(Canvas.TopProperty, StartDrawPoint.Y);	435	shape.SetValue(Canvas.TopProperty, StartDrawPoint.Y);
436	this.Children.Add(shape);	436	this.Children.Add(shape);
437	shapeList.Add(shape);	437	shapeList.Add(shape);
438		438
439	mouseState = MouseState.Draw;	439	mouseState = MouseState.Draw;
440	currentShape = shapeList.Count() - 1;	440	currentShape = shapeList.Count() - 1;
441		441
442	double shapeX = Canvas.GetLeft(shapeList[currentShape]);	442	double shapeX = Canvas.GetLeft(shapeList[currentShape]);
443	double shapeY = Canvas.GetTop(shapeList[currentShape]);	443	double shapeY = Canvas.GetTop(shapeList[currentShape]);
444	shapePosIndicator.Text = "(" + Math.Round(shapeX, 0) + "," + Math.Round(shapeY, 0) + ")";	444	shapePosIndicator.Text = "(" + Math.Round(shapeX, 0) + "," + Math.Round(shapeY, 0) + ")";
445	shapePosIndicator.SetValue(Canvas.LeftProperty, shapeX + indicatorAligment);	445	shapePosIndicator.SetValue(Canvas.LeftProperty, shapeX + indicatorAligment);
446	shapePosIndicator.SetValue(Canvas.TopProperty, shapeY + indicatorAligment);	446	shapePosIndicator.SetValue(Canvas.TopProperty, shapeY + indicatorAligment);
447		447
448	double width = (int)shapeList[currentShape].Width;	448	double width = (int)shapeList[currentShape].Width;
449	double height = (int)shapeList[currentShape].Height;	449	double height = (int)shapeList[currentShape].Height;
450	shapeSizeIndicator.Text = "(" + Math.Round(width, 0) + "," + Math.Round(height, 0) + ")";	450	shapeSizeIndicator.Text = "(" + Math.Round(width, 0) + "," + Math.Round(height, 0) + ")";
451	shapeSizeIndicator.SetValue(Canvas.LeftProperty, shapeX + indicatorAligment + width);	451	shapeSizeIndicator.SetValue(Canvas.LeftProperty, shapeX + indicatorAligment + width);
452	shapeSizeIndicator.SetValue(Canvas.TopProperty, shapeY + indicatorAligment + height);	452	shapeSizeIndicator.SetValue(Canvas.TopProperty, shapeY + indicatorAligment + height);
453		453
454	this.Children.Add(shapePosIndicator);	454	this.Children.Add(shapePosIndicator);
455	this.Children.Add(shapeSizeIndicator);	455	this.Children.Add(shapeSizeIndicator);
456		456
457		457
458	return;	458	return;
459	}	459	}
460	else	460	else
461	{	461	{
462	if (shapeList.Count() != 0)	462	if (shapeList.Count() != 0)
463	shapeList[currentShape].Fill = new SolidColorBrush(Colors.LightCyan);	463	shapeList[currentShape].Fill = new SolidColorBrush(Colors.LightCyan);
464		464
465	double shapeX = Canvas.GetLeft(shapeList[currentShape]);	465	double shapeX = Canvas.GetLeft(shapeList[currentShape]);
466	double shapeY = Canvas.GetTop(shapeList[currentShape]);	466	double shapeY = Canvas.GetTop(shapeList[currentShape]);
467	shapePosIndicator.Text = "(" + Math.Round(shapeX, 0) + "," + Math.Round(shapeY, 0) + ")";	467	shapePosIndicator.Text = "(" + Math.Round(shapeX, 0) + "," + Math.Round(shapeY, 0) + ")";
468	shapePosIndicator.SetValue(Canvas.LeftProperty, shapeX + indicatorAligment);	468	shapePosIndicator.SetValue(Canvas.LeftProperty, shapeX + indicatorAligment);
469	shapePosIndicator.SetValue(Canvas.TopProperty, shapeY + indicatorAligment);	469	shapePosIndicator.SetValue(Canvas.TopProperty, shapeY + indicatorAligment);
470		470
471	double width = (int)shapeList[currentShape].Width;	471	double width = (int)shapeList[currentShape].Width;
472	double height = (int)shapeList[currentShape].Height;	472	double height = (int)shapeList[currentShape].Height;
473	shapeSizeIndicator.Text = "(" + Math.Round(width, 0) + "," + Math.Round(height, 0) + ")";	473	shapeSizeIndicator.Text = "(" + Math.Round(width, 0) + "," + Math.Round(height, 0) + ")";
474	shapeSizeIndicator.SetValue(Canvas.LeftProperty, shapeX + indicatorAligment + width);	474	shapeSizeIndicator.SetValue(Canvas.LeftProperty, shapeX + indicatorAligment + width);
475	shapeSizeIndicator.SetValue(Canvas.TopProperty, shapeY + indicatorAligment + height);	475	shapeSizeIndicator.SetValue(Canvas.TopProperty, shapeY + indicatorAligment + height);
476		476
477	this.Children.Add(shapePosIndicator);	477	this.Children.Add(shapePosIndicator);
478	this.Children.Add(shapeSizeIndicator);	478	this.Children.Add(shapeSizeIndicator);
479	}	479	}
480		480
481	LastPoint = Mouse.GetPosition(this);	481	LastPoint = Mouse.GetPosition(this);
482	mouseState = MouseState.Drag;	482	mouseState = MouseState.Drag;
483	}	483	}
484	e.Handled = true;	484	e.Handled = true;
485	}	485	}
486		486
487	protected override void OnMouseMove(MouseEventArgs e)	487	protected override void OnMouseMove(MouseEventArgs e)
488	{	488	{
489	base.OnMouseMove(e);	489	base.OnMouseMove(e);
490		490
491	if (mouseState == MouseState.None)	491	if (mouseState == MouseState.None)
492	{	492	{
493	MouseHitType = SetHitType(Mouse.GetPosition(this));	493	MouseHitType = SetHitType(Mouse.GetPosition(this));
494	SetMouseCursor();	494	SetMouseCursor();
495	}	495	}
496	else if (Operation == OperationState.DrawRoute && isStartDrawRoute)	496	else if (Operation == OperationState.DrawRoute && isStartDrawRoute)
497	{	497	{
498	LineGeometry lineGeometry = (LineGeometry)gGrpLine.Children[currentLine];	498	LineGeometry lineGeometry = (LineGeometry)gGrpLine.Children[currentLine];
499		499
500	// See how much the mouse has moved.	500	// See how much the mouse has moved.
501	Point point = Mouse.GetPosition(this);	501	Point point = Mouse.GetPosition(this);
502	double offset_x = point.X - StartDrawPoint.X;	502	double offset_x = point.X - StartDrawPoint.X;
503	double offset_y = point.Y - StartDrawPoint.Y;	503	double offset_y = point.Y - StartDrawPoint.Y;
504		504
505	// Get the line's current position.	505	// Get the line's current position.
506	double new_x = lineGeometry.StartPoint.X;	506	double new_x = lineGeometry.StartPoint.X;
507	double new_y = lineGeometry.StartPoint.Y;	507	double new_y = lineGeometry.StartPoint.Y;
508		508
509	if (offset_x != 0 \|\| offset_y != 0)	509	if (offset_x != 0 \|\| offset_y != 0)
510	{	510	{
511	if (Math.Abs(offset_x) >= Math.Abs(offset_y))	511	if (Math.Abs(offset_x) >= Math.Abs(offset_y))
512	{	512	{
513	new_x = point.X;	513	new_x = point.X;
514	}	514	}
515	else	515	else
516	{	516	{
517	new_y = point.Y;	517	new_y = point.Y;
518	}	518	}
519	}	519	}
520		520
521	// Set end point of current line	521	// Set end point of current line
522	LastPoint = new Point(new_x, new_y);	522	LastPoint = new Point(new_x, new_y);
523	lineGeometry.EndPoint = LastPoint;	523	lineGeometry.EndPoint = LastPoint;
524	DisplayCoordinate(LastPoint);	524	DisplayCoordinate(LastPoint);
525	}	525	}
526	else if (Operation == OperationState.DrawObstract)	526	else if (Operation == OperationState.DrawObstract)
527	{	527	{
528	if (mouseState == MouseState.Drag)	528	if (mouseState == MouseState.Drag)
529	{	529	{
530	// See how much the mouse has moved.	530	// See how much the mouse has moved.
531	Point point = Mouse.GetPosition(this);	531	Point point = Mouse.GetPosition(this);
532	double offset_x = point.X - LastPoint.X;	532	double offset_x = point.X - LastPoint.X;
533	double offset_y = point.Y - LastPoint.Y;	533	double offset_y = point.Y - LastPoint.Y;
534		534
535	// Get the rectangle's current position.	535	// Get the rectangle's current position.
536	double new_x = Canvas.GetLeft(shapeList[currentShape]);	536	double new_x = Canvas.GetLeft(shapeList[currentShape]);
537	double new_y = Canvas.GetTop(shapeList[currentShape]);	537	double new_y = Canvas.GetTop(shapeList[currentShape]);
538	double new_width = shapeList[currentShape].Width;	538	double new_width = shapeList[currentShape].Width;
539	double new_height = shapeList[currentShape].Height;	539	double new_height = shapeList[currentShape].Height;
540		540
541	// Update the rectangle.	541	// Update the rectangle.
542	switch (MouseHitType)	542	switch (MouseHitType)
543	{	543	{
544	case HitType.Body:	544	case HitType.Body:
545	new_x += offset_x;	545	new_x += offset_x;
546	new_y += offset_y;	546	new_y += offset_y;
547	break;	547	break;
548	case HitType.UL:	548	case HitType.UL:
549	new_x += offset_x;	549	new_x += offset_x;
550	new_y += offset_y;	550	new_y += offset_y;
551	new_width -= offset_x;	551	new_width -= offset_x;
552	new_height -= offset_y;	552	new_height -= offset_y;
553	break;	553	break;
554	case HitType.UR:	554	case HitType.UR:
555	new_y += offset_y;	555	new_y += offset_y;
556	new_width += offset_x;	556	new_width += offset_x;
557	new_height -= offset_y;	557	new_height -= offset_y;
558	break;	558	break;
559	case HitType.LR:	559	case HitType.LR:
560	new_width += offset_x;	560	new_width += offset_x;
561	new_height += offset_y;	561	new_height += offset_y;
562	break;	562	break;
563	case HitType.LL:	563	case HitType.LL:
564	new_x += offset_x;	564	new_x += offset_x;
565	new_width -= offset_x;	565	new_width -= offset_x;
566	new_height += offset_y;	566	new_height += offset_y;
567	break;	567	break;
568	case HitType.L:	568	case HitType.L:
569	new_x += offset_x;	569	new_x += offset_x;
570	new_width -= offset_x;	570	new_width -= offset_x;
571	break;	571	break;
572	case HitType.R:	572	case HitType.R:
573	new_width += offset_x;	573	new_width += offset_x;
574	break;	574	break;
575	case HitType.B:	575	case HitType.B:
576	new_height += offset_y;	576	new_height += offset_y;
577	break;	577	break;
578	case HitType.T:	578	case HitType.T:
579	new_y += offset_y;	579	new_y += offset_y;
580	new_height -= offset_y;	580	new_height -= offset_y;
581	break;	581	break;
582	}	582	}
583	// Don't use negative width or height.	583	// Don't use negative width or height.
584	if ((new_width > 0) && (new_height > 0))	584	if ((new_width > 0) && (new_height > 0))
585	{	585	{
586	// Update the rectangle.	586	// Update the rectangle.
587	Canvas.SetLeft(shapeList[currentShape], new_x);	587	Canvas.SetLeft(shapeList[currentShape], new_x);
588	Canvas.SetTop(shapeList[currentShape], new_y);	588	Canvas.SetTop(shapeList[currentShape], new_y);
589	shapeList[currentShape].Width = new_width;	589	shapeList[currentShape].Width = new_width;
590	shapeList[currentShape].Height = new_height;	590	shapeList[currentShape].Height = new_height;
591		591
592	// Save the mouse's new location.	592	// Save the mouse's new location.
593	LastPoint = point;	593	LastPoint = point;
594		594
595	}	595	}
596	}	596	}
597	else if (mouseState == MouseState.Draw)	597	else if (mouseState == MouseState.Draw)
598	{	598	{
599		599
600	// See how much the mouse has moved.	600	// See how much the mouse has moved.
601	Point point = Mouse.GetPosition(this);	601	Point point = Mouse.GetPosition(this);
602		602
603		603
604	double offset_x = point.X - StartDrawPoint.X;	604	double offset_x = point.X - StartDrawPoint.X;
605	double offset_y = point.Y - StartDrawPoint.Y;	605	double offset_y = point.Y - StartDrawPoint.Y;
606		606
607	// Get the rectangle's current position.	607	// Get the rectangle's current position.
608	double start_x = Canvas.GetLeft(shapeList[currentShape]);	608	double start_x = Canvas.GetLeft(shapeList[currentShape]);
609	double start_y = Canvas.GetTop(shapeList[currentShape]);	609	double start_y = Canvas.GetTop(shapeList[currentShape]);
610	double new_x = Canvas.GetLeft(shapeList[currentShape]);	610	double new_x = Canvas.GetLeft(shapeList[currentShape]);
611	double new_y = Canvas.GetTop(shapeList[currentShape]);	611	double new_y = Canvas.GetTop(shapeList[currentShape]);
612	double new_width = offset_x;	612	double new_width = offset_x;
613	double new_height = offset_y;	613	double new_height = offset_y;
614	if (offset_x < 0)	614	if (offset_x < 0)
615	{	615	{
616	new_x = point.X;	616	new_x = point.X;
617	new_width = -offset_x;	617	new_width = -offset_x;
618	}	618	}
619	if (offset_y < 0)	619	if (offset_y < 0)
620	{	620	{
621	new_y = point.Y;	621	new_y = point.Y;
622	new_height = -offset_y;	622	new_height = -offset_y;
623	}	623	}
624	Canvas.SetLeft(shapeList[currentShape], new_x);	624	Canvas.SetLeft(shapeList[currentShape], new_x);
625	Canvas.SetTop(shapeList[currentShape], new_y);	625	Canvas.SetTop(shapeList[currentShape], new_y);
626	shapeList[currentShape].Width = new_width;	626	shapeList[currentShape].Width = new_width;
627	shapeList[currentShape].Height = new_height;	627	shapeList[currentShape].Height = new_height;
628		628
629	}	629	}
630		630
631	double shapeX = Canvas.GetLeft(shapeList[currentShape]);	631	double shapeX = Canvas.GetLeft(shapeList[currentShape]);
632	double shapeY = Canvas.GetTop(shapeList[currentShape]);	632	double shapeY = Canvas.GetTop(shapeList[currentShape]);
633	shapePosIndicator.Text = "(" + Math.Round(shapeX, 0) + "," + Math.Round(shapeY, 0) + ")";	633	shapePosIndicator.Text = "(" + Math.Round(shapeX, 0) + "," + Math.Round(shapeY, 0) + ")";
634	shapePosIndicator.SetValue(Canvas.LeftProperty, shapeX + indicatorAligment);	634	shapePosIndicator.SetValue(Canvas.LeftProperty, shapeX + indicatorAligment);
635	shapePosIndicator.SetValue(Canvas.TopProperty, shapeY + indicatorAligment);	635	shapePosIndicator.SetValue(Canvas.TopProperty, shapeY + indicatorAligment);
636		636
637	double width = (int)shapeList[currentShape].Width;	637	double width = (int)shapeList[currentShape].Width;
638	double height = (int)shapeList[currentShape].Height;	638	double height = (int)shapeList[currentShape].Height;
639	shapeSizeIndicator.Text = "(" + Math.Round(width, 0) + "," + Math.Round(height, 0) + ")";	639	shapeSizeIndicator.Text = "(" + Math.Round(width, 0) + "," + Math.Round(height, 0) + ")";
640	shapeSizeIndicator.SetValue(Canvas.LeftProperty, shapeX + indicatorAligment + width);	640	shapeSizeIndicator.SetValue(Canvas.LeftProperty, shapeX + indicatorAligment + width);
641	shapeSizeIndicator.SetValue(Canvas.TopProperty, shapeY + indicatorAligment + height);	641	shapeSizeIndicator.SetValue(Canvas.TopProperty, shapeY + indicatorAligment + height);
642	}	642	}
643	e.Handled = true;	643	e.Handled = true;
644	}	644	}
645		645
646	protected override void OnMouseUp(MouseButtonEventArgs e)	646	protected override void OnMouseUp(MouseButtonEventArgs e)
647	{	647	{
648	base.OnMouseUp(e);	648	base.OnMouseUp(e);
649	if (Operation == OperationState.DrawObstract)	649	if (Operation == OperationState.DrawObstract)
650	{	650	{
651	if (shapeList.Count() != 0)	651	if (shapeList.Count() != 0)
652	shapeList[currentShape].Fill = new SolidColorBrush(Colors.Blue);	652	shapeList[currentShape].Fill = new SolidColorBrush(Colors.Blue);
653	shapePosIndicator.Text = "";	653	shapePosIndicator.Text = "";
654	shapeSizeIndicator.Text = "";	654	shapeSizeIndicator.Text = "";
655	this.Children.Remove(shapePosIndicator);	655	this.Children.Remove(shapePosIndicator);
656	this.Children.Remove(shapeSizeIndicator);	656	this.Children.Remove(shapeSizeIndicator);
657		657
658	mouseState = MouseState.None;	658	mouseState = MouseState.None;
659	currentShape = 0;	659	currentShape = 0;
660	}	660	}
661	e.Handled = true;	661	e.Handled = true;
662	}	662	}
663		663
664	protected override void OnPreviewMouseUp(MouseButtonEventArgs e)	664	protected override void OnPreviewMouseUp(MouseButtonEventArgs e)
665	{	665	{
666	base.OnPreviewMouseUp(e);	666	base.OnPreviewMouseUp(e);
667		667
668	EllipseGeometry ellipseGeometry;	668	EllipseGeometry ellipseGeometry;
669	bool flag = false;	669	bool flag = false;
670		670
671	StartDrawPoint = e.MouseDevice.GetPosition(this);	671	StartDrawPoint = e.MouseDevice.GetPosition(this);
672		672
673	if (EditNodeFlag == true)	673	if (EditNodeFlag == true)
674	{	674	{
675	execEditNode(StartDrawPoint);	675	execEditNode(StartDrawPoint);
676	EditNodeFlag = false;	676	EditNodeFlag = false;
677	return;	677	return;
678	}	678	}
679		679
680	if (DragDeltaFlag == true)	680	if (DragDeltaFlag == true)
681	{	681	{
682	for (int i = 0; i < gGrpBlueNode.Children.Count; i++)	682	for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
683	{	683	{
684		684
685	for (int j = 0; j < ucNode_Lst.Count; j++)	685	for (int j = 0; j < ucNode_Lst.Count; j++)
686	{	686	{
687	if (j == i)	687	if (j == i)
688	{	688	{
689	_ucNodeFree = ucNode_Lst[j];	689	_ucNodeFree = ucNode_Lst[j];
690	flag = true;	690	flag = true;
691	}	691	}
692	}	692	}
693	if (flag)	693	if (flag)
694	{	694	{
695	if (gGrpNewLine.Children.Count > 0)	695	if (gGrpNewLine.Children.Count > 0)
696	{	696	{
697	for (int k = 0; k < gGrpNewLine.Children.Count; k++)	697	for (int k = 0; k < gGrpNewLine.Children.Count; k++)
698	{	698	{
699	LineGeometry lineGeometry = (LineGeometry)gGrpNewLine.Children[k];	699	LineGeometry lineGeometry = (LineGeometry)gGrpNewLine.Children[k];
700	Point p1 = lineGeometry.StartPoint;	700	Point p1 = lineGeometry.StartPoint;
701	Point p2 = lineGeometry.EndPoint;	701	Point p2 = lineGeometry.EndPoint;
702		702
703	//bool pInL = PointInLine(StartDrawPoint, p1, p2, 25);	703	//bool pInL = PointInLine(StartDrawPoint, p1, p2, 25);
704		704
705	//if (pInL)	705	//if (pInL)
706	//{	706	//{
707		707
708	// //this.Children.Remove(_ucNodeFree);	708	// //this.Children.Remove(_ucNodeFree);
709	// //this.Children.Add(_ucNodeFree);	709	// //this.Children.Add(_ucNodeFree);
710	// return;	710	// return;
711	//}	711	//}
712	}	712	}
713	}	713	}
714		714
715	ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];	715	ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
716		716
717	ellipseGeometry.Center = new Point(StartDrawPoint.X, StartDrawPoint.Y);	717	ellipseGeometry.Center = new Point(StartDrawPoint.X, StartDrawPoint.Y);
718		718
719	double centerY = Canvas.GetTop(_ucNodeFree);	719	double centerY = Canvas.GetTop(_ucNodeFree);
720	double centerX = Canvas.GetLeft(_ucNodeFree);	720	double centerX = Canvas.GetLeft(_ucNodeFree);
721		721
722	mouseState = MouseState.Draw;	722	mouseState = MouseState.Draw;
723		723
724		724
725	StartDrawPoint = new Point(centerX + UCNODE_SETLEFT, centerY + UCNODE_SETTOP);	725	StartDrawPoint = new Point(centerX + UCNODE_SETLEFT, centerY + UCNODE_SETTOP);
726	ellipseGeometry.Center = new Point(centerX + UCNODE_SETLEFT, centerY + UCNODE_SETTOP);	726	ellipseGeometry.Center = new Point(centerX + UCNODE_SETLEFT, centerY + UCNODE_SETTOP);
727		727
728	this.Children.Remove(_ucNodeFree);	728	this.Children.Remove(_ucNodeFree);
729	this.Children.Add(_ucNodeFree);	729	this.Children.Add(_ucNodeFree);
730	Lst_Node_tmp[i].pointMap_X = ConvertPointDisplayToActual(StartDrawPoint.X, Scale_X, PointMapStart_X);	730	Lst_Node_tmp[i].pointMap_X = ConvertPointDisplayToActual(StartDrawPoint.X, Scale_X, PointMapStart_X);
731	Lst_Node_tmp[i].pointMap_Y = ConvertPointDisplayToActual(StartDrawPoint.Y, Scale_X, PointMapStart_Y);	731	Lst_Node_tmp[i].pointMap_Y = ConvertPointDisplayToActual(StartDrawPoint.Y, Scale_X, PointMapStart_Y);
732		732
733	//Update Location for List NameNode_List -> Compare Location to get Name	733	//Update Location for List NameNode_List -> Compare Location to get Name
734	ListNameNode nmNode = new ListNameNode();	734	ListNameNode nmNode = new ListNameNode();
735	ListNameNode nmNode_old = new ListNameNode();	735	ListNameNode nmNode_old = new ListNameNode();
736	nmNode_old = NameNode_List[i];	736	nmNode_old = NameNode_List[i];
737		737
738	nmNode.X = StartDrawPoint.X;	738	nmNode.X = StartDrawPoint.X;
739	nmNode.Y = StartDrawPoint.Y;	739	nmNode.Y = StartDrawPoint.Y;
740	nmNode.nameNode = nmNode_old.nameNode;	740	nmNode.nameNode = nmNode_old.nameNode;
741	NameNode_List[i] = nmNode;	741	NameNode_List[i] = nmNode;
742	}	742	}
743	}	743	}
744		744
745	ReDrawAllNode();	745	ReDrawAllNode();
746	NewDspRouteInfo();	746	NewDspRouteInfo();
747		747
748	SetScheduleRoute();	748	SetScheduleRoute();
749	DragDeltaFlag = false;	749	DragDeltaFlag = false;
750	}	750	}
751		751
752		752
753		753
754	return;	754	return;
755	}	755	}
756		756
757	/// <summary>	757	/// <summary>
758	/// On Preview Mouse Down	758	/// On Preview Mouse Down
759	/// </summary>	759	/// </summary>
760	/// <param name="e"></param>	760	/// <param name="e"></param>
761	protected override void OnPreviewMouseDown(MouseButtonEventArgs e)	761	protected override void OnPreviewMouseDown(MouseButtonEventArgs e)
762	{	762	{
763	base.OnPreviewMouseDown(e);	763	base.OnPreviewMouseDown(e);
764		764
765	if (DesignerCanvas.LoadDBFlag)	765	if (DesignerCanvas.LoadDBFlag)
766	return;	766	return;
767		767
768	if (Operation != OperationState.NewDrawSetFreeNode)	768	if (Operation != OperationState.NewDrawSetFreeNode)
769	{	769	{
770	return;	770	return;
771	}	771	}
772		772
773	Point currentPoint = e.MouseDevice.GetPosition(this);	773	Point currentPoint = e.MouseDevice.GetPosition(this);
774		774
775	if (isDrawingNode == false)	775	if (isDrawingNode == false)
776	{	776	{
777		777
778	isDrawingNode = true;	778	isDrawingNode = true;
779	//InitDrawRoute();	779	//InitDrawRoute();
780	mouseState = MouseState.Draw;	780	mouseState = MouseState.Draw;
781		781
782	StartDrawPoint = e.MouseDevice.GetPosition(this);	782	StartDrawPoint = e.MouseDevice.GetPosition(this);
783		783
784		784
785	execCreateNode(StartDrawPoint);	785	execCreateNode(StartDrawPoint);
786		786
787	//backup DB	787	//backup DB
788	CreateVehicleNode();	788	CreateVehicleNode();
789		789
790	return;	790	return;
791	}	791	}
792	else	792	else
793	{	793	{
794		794
795	bool RightClick = false;	795	bool RightClick = false;
796	bool LeftClick = false;	796	bool LeftClick = false;
797		797
798		798
799	if (IsMouseLeftClick(e))	799	if (IsMouseLeftClick(e))
800	LeftClick = true;	800	LeftClick = true;
801	if (IsStopDrawRoute(e))	801	if (IsStopDrawRoute(e))
802	RightClick = true;	802	RightClick = true;
803		803
804	StartDrawPoint = e.MouseDevice.GetPosition(this);	804	StartDrawPoint = e.MouseDevice.GetPosition(this);
805		805
806	if (RightClick)	806	if (RightClick)
807	{	807	{
808	execDeleteNode(StartDrawPoint);	808	execDeleteNode(StartDrawPoint);
809		809
810	//backup DB	810	//backup DB
811	CreateVehicleNode();	811	CreateVehicleNode();
812	}	812	}
813	else if (LeftClick)	813	else if (LeftClick)
814	{	814	{
815	//check click to exist node	815	//check click to exist node
816	for (int i = 0; i < gGrpBlueNode.Children.Count; i++)	816	for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
817	{	817	{
818	EllipseGeometry ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];	818	EllipseGeometry ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
819	Point node = ellipseGeometry.Center;	819	Point node = ellipseGeometry.Center;
820	bool isEditNode = CheckIsNode(StartDrawPoint, node, RADIUS_NODE);	820	bool isEditNode = CheckIsNode(StartDrawPoint, node, RADIUS_NODE);
821		821
822	if (isEditNode)	822	if (isEditNode)
823	{	823	{
824	return;	824	return;
825	}	825	}
826	}	826	}
827		827
828	execCreateNode(StartDrawPoint);	828	execCreateNode(StartDrawPoint);
829		829
830	//backup DB	830	//backup DB
831	CreateVehicleNode();	831	CreateVehicleNode();
832	}	832	}
833		833
834	}	834	}
835	}	835	}
836		836
837	#region Functions for draw route	837	#region Functions for draw route
838		838
839	/// <summary>	839	/// <summary>
840	/// Check start or end draw route	840	/// Check start or end draw route
841	/// </summary>	841	/// </summary>
842	/// <param name="_ucStartEndButton">Button start</param>	842	/// <param name="_ucStartEndButton">Button start</param>
843	/// <param name="currentPoint">Position for check</param>	843	/// <param name="currentPoint">Position for check</param>
844	/// <returns>true: start, false: not start</returns>	844	/// <returns>true: start, false: not start</returns>
845	private bool IsStartEndRoute(ucStartEndButton _ucStartEndButton, Point currentPoint)	845	private bool IsStartEndRoute(ucStartEndButton _ucStartEndButton, Point currentPoint)
846	{	846	{
847	if (_ucStartEndButton == null)	847	if (_ucStartEndButton == null)
848	{	848	{
849	return false;	849	return false;
850	}	850	}
851		851
852	double centerX = Canvas.GetLeft(_ucStartEndButton);	852	double centerX = Canvas.GetLeft(_ucStartEndButton);
853	double centerY = Canvas.GetTop(_ucStartEndButton);	853	double centerY = Canvas.GetTop(_ucStartEndButton);
854		854
855	if (currentPoint.X < centerX + 50 && currentPoint.X > centerX	855	if (currentPoint.X < centerX + 50 && currentPoint.X > centerX
856	&& currentPoint.Y < centerY + 50 && currentPoint.Y > centerY)	856	&& currentPoint.Y < centerY + 50 && currentPoint.Y > centerY)
857	{	857	{
858	return true;	858	return true;
859	}	859	}
860	return false;	860	return false;
861	}	861	}
862		862
863	/// <summary>	863	/// <summary>
864	/// Process when end draw route	864	/// Process when end draw route
865	/// </summary>	865	/// </summary>
866	private void ProcessEndRoute()	866	private void ProcessEndRoute()
867	{	867	{
868	Operation = OperationState.None;	868	Operation = OperationState.None;
869	AutoEditLine();	869	AutoEditLine();
870	this.Children.Remove(_displayAxiPosition);	870	this.Children.Remove(_displayAxiPosition);
871	this.Children.Remove(_goalPoint);	871	this.Children.Remove(_goalPoint);
872	this.Children.Add(_goalPoint);	872	this.Children.Add(_goalPoint);
873	}	873	}
874		874
875	/// <summary>	875	/// <summary>
876	/// Check end draw route	876	/// Check end draw route
877	/// </summary>	877	/// </summary>
878	/// <param name="_ucStartEndButton">Button end</param>	878	/// <param name="_ucStartEndButton">Button end</param>
879	/// <param name="currentPoint">Position for check</param>	879	/// <param name="currentPoint">Position for check</param>
880	/// <returns>true: end, false: not end</returns>	880	/// <returns>true: end, false: not end</returns>
881	private bool IsEndRoute(ucStartEndButton _ucStartEndButton, LineGeometry lineGeometry)	881	private bool IsEndRoute(ucStartEndButton _ucStartEndButton, LineGeometry lineGeometry)
882	{	882	{
883	if (_ucStartEndButton == null)	883	if (_ucStartEndButton == null)
884	{	884	{
885	return false;	885	return false;
886	}	886	}
887		887
888	double centerX = Canvas.GetLeft(_ucStartEndButton);	888	double centerX = Canvas.GetLeft(_ucStartEndButton);
889	double centerY = Canvas.GetTop(_ucStartEndButton);	889	double centerY = Canvas.GetTop(_ucStartEndButton);
890	Point startPoint = lineGeometry.StartPoint;	890	Point startPoint = lineGeometry.StartPoint;
891	Point endPoint = lineGeometry.EndPoint;	891	Point endPoint = lineGeometry.EndPoint;
892		892
893	if (IsVerticalLine(lineGeometry))	893	if (IsVerticalLine(lineGeometry))
894	{	894	{
895	if (endPoint.X < centerX \|\| endPoint.X > centerX + 50)	895	if (endPoint.X < centerX \|\| endPoint.X > centerX + 50)
896	return false;	896	return false;
897		897
898	if (startPoint.Y > centerY + 50 && endPoint.Y > centerY + 50)	898	if (startPoint.Y > centerY + 50 && endPoint.Y > centerY + 50)
899	return false;	899	return false;
900		900
901	if (startPoint.Y < centerY && endPoint.Y < centerY)	901	if (startPoint.Y < centerY && endPoint.Y < centerY)
902	return false;	902	return false;
903	}	903	}
904	else	904	else
905	{	905	{
906	if (endPoint.Y < centerY \|\| endPoint.Y > centerY + 50)	906	if (endPoint.Y < centerY \|\| endPoint.Y > centerY + 50)
907	return false;	907	return false;
908		908
909	if (startPoint.X > centerX + 50 && endPoint.X > centerX + 50)	909	if (startPoint.X > centerX + 50 && endPoint.X > centerX + 50)
910	return false;	910	return false;
911		911
912	if (startPoint.X < centerX && endPoint.X < centerX)	912	if (startPoint.X < centerX && endPoint.X < centerX)
913	return false;	913	return false;
914	}	914	}
915		915
916	return true;	916	return true;
917	}	917	}
918		918
919	/// <summary>	919	/// <summary>
920	/// Make root	920	/// Make root
921	/// </summary>	921	/// </summary>
922	public void MakeRoot()	922	public void MakeRoot()
923	{	923	{
924	// If still not route	924	// If still not route
925	if (gGrpLine.Children.Count == 0)	925	if (gGrpLine.Children.Count == 0)
926	return;	926	return;
927		927
928	pLine.Stroke = new SolidColorBrush(Colors.Red);	928	pLine.Stroke = new SolidColorBrush(Colors.Red);
929	pLine.StrokeThickness = STROKE_ROOT_LINE;	929	pLine.StrokeThickness = STROKE_ROOT_LINE;
930		930
931	}	931	}
932		932
933	/// <summary>	933	/// <summary>
934	/// Auto edit leght of line	934	/// Auto edit leght of line
935	/// </summary>	935	/// </summary>
936	private void AutoEditLine()	936	private void AutoEditLine()
937	{	937	{
938	double temp;	938	double temp;
939	int index = gGrpLine.Children.Count - 1;	939	int index = gGrpLine.Children.Count - 1;
940	double centerY = Canvas.GetTop(_goalPoint) + 25;	940	double centerY = Canvas.GetTop(_goalPoint) + 25;
941	double centerX = Canvas.GetLeft(_goalPoint) + 25;	941	double centerX = Canvas.GetLeft(_goalPoint) + 25;
942	LineGeometry lastLine = (LineGeometry)gGrpLine.Children[index];	942	LineGeometry lastLine = (LineGeometry)gGrpLine.Children[index];
943	LineGeometry beforeLastLine = (LineGeometry)gGrpLine.Children[index];	943	LineGeometry beforeLastLine = (LineGeometry)gGrpLine.Children[index];
944		944
945	if (gGrpLine.Children.Count > 1)	945	if (gGrpLine.Children.Count > 1)
946	{	946	{
947	beforeLastLine = (LineGeometry)gGrpLine.Children[index - 1];	947	beforeLastLine = (LineGeometry)gGrpLine.Children[index - 1];
948		948
949	if (!IsCurverNode(beforeLastLine, lastLine))	949	if (!IsCurverNode(beforeLastLine, lastLine))
950	{	950	{
951	beforeLastLine.EndPoint = lastLine.EndPoint;	951	beforeLastLine.EndPoint = lastLine.EndPoint;
952	gGrpLine.Children.RemoveAt(index);	952	gGrpLine.Children.RemoveAt(index);
953	index = index - 1;	953	index = index - 1;
954	lastLine = (LineGeometry)gGrpLine.Children[index];	954	lastLine = (LineGeometry)gGrpLine.Children[index];
955	}	955	}
956	}	956	}
957		957
958	if (index == gGrpRedNode.Children.Count + 1)	958	if (index == gGrpRedNode.Children.Count + 1)
959	{	959	{
960	AddNode(lastLine.StartPoint, gGrpRedNode);	960	AddNode(lastLine.StartPoint, gGrpRedNode);
961	}	961	}
962		962
963	if (lastLine.EndPoint.X == centerX && lastLine.EndPoint.Y == centerY)	963	if (lastLine.EndPoint.X == centerX && lastLine.EndPoint.Y == centerY)
964	return;	964	return;
965		965
966	if (IsVerticalLine(lastLine))	966	if (IsVerticalLine(lastLine))
967	{	967	{
968	temp = lastLine.StartPoint.Y;	968	temp = lastLine.StartPoint.Y;
969	lastLine.StartPoint = new Point(centerX, temp);	969	lastLine.StartPoint = new Point(centerX, temp);
970	lastLine.EndPoint = new Point(centerX, centerY);	970	lastLine.EndPoint = new Point(centerX, centerY);
971		971
972	if (gGrpLine.Children.Count > 1)	972	if (gGrpLine.Children.Count > 1)
973	{	973	{
974	beforeLastLine = (LineGeometry)gGrpLine.Children[index - 1];	974	beforeLastLine = (LineGeometry)gGrpLine.Children[index - 1];
975	temp = beforeLastLine.EndPoint.Y;	975	temp = beforeLastLine.EndPoint.Y;
976	beforeLastLine.EndPoint = new Point(centerX, temp);	976	beforeLastLine.EndPoint = new Point(centerX, temp);
977	}	977	}
978	}	978	}
979	else	979	else
980	{	980	{
981	temp = lastLine.StartPoint.X;	981	temp = lastLine.StartPoint.X;
982	lastLine.StartPoint = new Point(temp, centerY);	982	lastLine.StartPoint = new Point(temp, centerY);
983	lastLine.EndPoint = new Point(centerX, centerY);	983	lastLine.EndPoint = new Point(centerX, centerY);
984	if (gGrpLine.Children.Count > 1)	984	if (gGrpLine.Children.Count > 1)
985	{	985	{
986	beforeLastLine = (LineGeometry)gGrpLine.Children[index - 1];	986	beforeLastLine = (LineGeometry)gGrpLine.Children[index - 1];
987	temp = beforeLastLine.EndPoint.X;	987	temp = beforeLastLine.EndPoint.X;
988	beforeLastLine.EndPoint = new Point(temp, centerY);	988	beforeLastLine.EndPoint = new Point(temp, centerY);
989	}	989	}
990	}	990	}
991		991
992	// Draw curver line	992	// Draw curver line
993	if (IsCurverNode(beforeLastLine, lastLine))	993	if (IsCurverNode(beforeLastLine, lastLine))
994	{	994	{
995	EllipseGeometry ellipseGeometry = (EllipseGeometry)gGrpRedNode.Children[gGrpRedNode.Children.Count - 1];	995	EllipseGeometry ellipseGeometry = (EllipseGeometry)gGrpRedNode.Children[gGrpRedNode.Children.Count - 1];
996	ellipseGeometry.Center = lastLine.StartPoint;	996	ellipseGeometry.Center = lastLine.StartPoint;
997	}	997	}
998	}	998	}
999		999
1000	/// <summary>	1000	/// <summary>
1001	/// Check draw curver node	1001	/// Check draw curver node
1002	/// </summary>	1002	/// </summary>
1003	/// <param name="oldLine">Old line</param>	1003	/// <param name="oldLine">Old line</param>
1004	/// <param name="newLine">New line</param>	1004	/// <param name="newLine">New line</param>
1005	/// <returns>true:is curver, fasle: not curver</returns>	1005	/// <returns>true:is curver, fasle: not curver</returns>
1006	private bool IsCurverNode(LineGeometry oldLine, LineGeometry newLine)	1006	private bool IsCurverNode(LineGeometry oldLine, LineGeometry newLine)
1007	{	1007	{
1008	if (oldLine.StartPoint.Y == oldLine.EndPoint.Y && oldLine.StartPoint.Y == newLine.EndPoint.Y)	1008	if (oldLine.StartPoint.Y == oldLine.EndPoint.Y && oldLine.StartPoint.Y == newLine.EndPoint.Y)
1009	{	1009	{
1010	return false;	1010	return false;
1011	}	1011	}
1012		1012
1013	if (oldLine.StartPoint.X == oldLine.EndPoint.X && oldLine.StartPoint.X == newLine.EndPoint.X)	1013	if (oldLine.StartPoint.X == oldLine.EndPoint.X && oldLine.StartPoint.X == newLine.EndPoint.X)
1014	{	1014	{
1015	return false;	1015	return false;
1016	}	1016	}
1017		1017
1018	return true;	1018	return true;
1019	}	1019	}
1020		1020
1021	/// <summary>	1021	/// <summary>
1022	/// Check timming to stop draw route	1022	/// Check timming to stop draw route
1023	/// </summary>	1023	/// </summary>
1024	/// <param name="e"></param>	1024	/// <param name="e"></param>
1025	/// <returns>true:stop; false:continue</returns>	1025	/// <returns>true:stop; false:continue</returns>
1026	private bool IsStopDrawRoute(MouseEventArgs e)	1026	private bool IsStopDrawRoute(MouseEventArgs e)
1027	{	1027	{
1028	if (e.RightButton == MouseButtonState.Pressed)	1028	if (e.RightButton == MouseButtonState.Pressed)
1029	{	1029	{
1030	return true;	1030	return true;
1031	}	1031	}
1032		1032
1033	return false;	1033	return false;
1034	}	1034	}
1035		1035
1036	//2017/03/05 NAM ADD START	1036	//2017/03/05 NAM ADD START
1037	private bool IsMouseLeftClick(MouseEventArgs e)	1037	private bool IsMouseLeftClick(MouseEventArgs e)
1038	{	1038	{
1039	if (e.LeftButton == MouseButtonState.Pressed)	1039	if (e.LeftButton == MouseButtonState.Pressed)
1040	{	1040	{
1041	return true;	1041	return true;
1042	}	1042	}
1043		1043
1044	return false;	1044	return false;
1045	}	1045	}
1046	//2017/03/05 NAM ADD END	1046	//2017/03/05 NAM ADD END
1047		1047
1048	/// <summary>	1048	/// <summary>
1049	/// Draw curver line and yellow node	1049	/// Draw curver line and yellow node
1050	/// </summary>	1050	/// </summary>
1051	/// <param name="oldLine">Old line</param>	1051	/// <param name="oldLine">Old line</param>
1052	/// <param name="newLine">New line</param>	1052	/// <param name="newLine">New line</param>
1053	private void DrawCurver(LineGeometry oldLine, LineGeometry newLine)	1053	private void DrawCurver(LineGeometry oldLine, LineGeometry newLine)
1054	{	1054	{
1055	double radius = RADIUS_CURVER_LINE;	1055	double radius = RADIUS_CURVER_LINE;
1056		1056
1057	Point startPoint;	1057	Point startPoint;
1058	Point endPoint;	1058	Point endPoint;
1059		1059
1060	// Get postion of yellow node on old line	1060	// Get postion of yellow node on old line
1061	if (IsVerticalLine(oldLine))	1061	if (IsVerticalLine(oldLine))
1062	{	1062	{
1063	if (oldLine.StartPoint.Y > oldLine.EndPoint.Y)	1063	if (oldLine.StartPoint.Y > oldLine.EndPoint.Y)
1064	startPoint = new Point(oldLine.EndPoint.X, oldLine.EndPoint.Y + radius);	1064	startPoint = new Point(oldLine.EndPoint.X, oldLine.EndPoint.Y + radius);
1065	else	1065	else
1066	startPoint = new Point(oldLine.EndPoint.X, oldLine.EndPoint.Y - radius);	1066	startPoint = new Point(oldLine.EndPoint.X, oldLine.EndPoint.Y - radius);
1067	}	1067	}
1068	else	1068	else
1069	{	1069	{
1070	if (oldLine.StartPoint.X > oldLine.EndPoint.X)	1070	if (oldLine.StartPoint.X > oldLine.EndPoint.X)
1071	startPoint = new Point(oldLine.EndPoint.X + radius, oldLine.EndPoint.Y);	1071	startPoint = new Point(oldLine.EndPoint.X + radius, oldLine.EndPoint.Y);
1072	else	1072	else
1073	startPoint = new Point(oldLine.EndPoint.X - radius, oldLine.EndPoint.Y);	1073	startPoint = new Point(oldLine.EndPoint.X - radius, oldLine.EndPoint.Y);
1074	}	1074	}
1075		1075
1076	// Get postion of yellow node on new line	1076	// Get postion of yellow node on new line
1077	if (IsVerticalLine(newLine))	1077	if (IsVerticalLine(newLine))
1078	{	1078	{
1079	if (newLine.StartPoint.Y > newLine.EndPoint.Y)	1079	if (newLine.StartPoint.Y > newLine.EndPoint.Y)
1080	endPoint = new Point(newLine.StartPoint.X, newLine.StartPoint.Y - radius);	1080	endPoint = new Point(newLine.StartPoint.X, newLine.StartPoint.Y - radius);
1081	else	1081	else
1082	endPoint = new Point(newLine.StartPoint.X, newLine.StartPoint.Y + radius);	1082	endPoint = new Point(newLine.StartPoint.X, newLine.StartPoint.Y + radius);
1083	}	1083	}
1084	else	1084	else
1085	{	1085	{
1086	if (newLine.StartPoint.X > newLine.EndPoint.X)	1086	if (newLine.StartPoint.X > newLine.EndPoint.X)
1087	endPoint = new Point(newLine.StartPoint.X - radius, newLine.StartPoint.Y);	1087	endPoint = new Point(newLine.StartPoint.X - radius, newLine.StartPoint.Y);
1088	else	1088	else
1089	endPoint = new Point(newLine.StartPoint.X + radius, newLine.StartPoint.Y);	1089	endPoint = new Point(newLine.StartPoint.X + radius, newLine.StartPoint.Y);
1090	}	1090	}
1091		1091
1092	// Add node to postion distance 1300mm	1092	// Add node to postion distance 1300mm
1093	if (GetDistance(oldLine.StartPoint, oldLine.EndPoint) > RADIUS_CURVER_LINE)	1093	if (GetDistance(oldLine.StartPoint, oldLine.EndPoint) > RADIUS_CURVER_LINE)
1094	{	1094	{
1095	AddNode(startPoint, gGrpYellowNode);	1095	AddNode(startPoint, gGrpYellowNode);
1096	}	1096	}
1097		1097
1098	if (GetDistance(newLine.StartPoint, newLine.EndPoint) > RADIUS_CURVER_LINE)	1098	if (GetDistance(newLine.StartPoint, newLine.EndPoint) > RADIUS_CURVER_LINE)
1099	{	1099	{
1100	AddNode(endPoint, gGrpYellowNode);	1100	AddNode(endPoint, gGrpYellowNode);
1101	}	1101	}
1102	}	1102	}
1103		1103
1104	/// <summary>	1104	/// <summary>
1105	/// Init data for draw route	1105	/// Init data for draw route
1106	/// </summary>	1106	/// </summary>
1107	public void InitDrawRoute()	1107	public void InitDrawRoute()
1108	{	1108	{
1109	//2017/03/04 NAM ADD START	1109	//2017/03/04 NAM ADD START
1110	pNewLine.Stroke = new SolidColorBrush(Colors.Red);	1110	pNewLine.Stroke = new SolidColorBrush(Colors.Red);
1111	pNewLine.StrokeThickness = STROKE_LINE;	1111	pNewLine.StrokeThickness = STROKE_LINE;
1112	pNewLine.Data = gGrpNewLine;	1112	pNewLine.Data = gGrpNewLine;
1113	//2017/03/04 NAM ADD END	1113	//2017/03/04 NAM ADD END
1114		1114
1115	pScheduleLine.Stroke = new SolidColorBrush(Colors.Red);	1115	pScheduleLine.Stroke = new SolidColorBrush(Colors.Red);
1116	pScheduleLine.StrokeThickness = STROKE_LINE;	1116	pScheduleLine.StrokeThickness = STROKE_LINE;
1117	pScheduleLine.Data = gGrpScheduleLine;	1117	pScheduleLine.Data = gGrpScheduleLine;
1118		1118
1119	// Setting for path line	1119	// Setting for path line
1120	pLine.Stroke = new SolidColorBrush(Colors.Blue);	1120	pLine.Stroke = new SolidColorBrush(Colors.Blue);
1121	pLine.StrokeThickness = STROKE_LINE;	1121	pLine.StrokeThickness = STROKE_LINE;
1122	pLine.Data = gGrpLine;	1122	pLine.Data = gGrpLine;
1123		1123
1124	// Setting for path of curver line	1124	// Setting for path of curver line
1125	pCurverLine.Stroke = Brushes.Red;	1125	pCurverLine.Stroke = Brushes.Red;
1126	pCurverLine.StrokeThickness = STROKE_LINE;	1126	pCurverLine.StrokeThickness = STROKE_LINE;
1127	pCurverLine.Data = gGrpCurverLine;	1127	pCurverLine.Data = gGrpCurverLine;
1128		1128
1129	// Setting for path of red node	1129	// Setting for path of red node
1130	pRedNode.Stroke = new SolidColorBrush(Colors.Blue);	1130	pRedNode.Stroke = new SolidColorBrush(Colors.Blue);
1131	pRedNode.Fill = new SolidColorBrush(Colors.Red);	1131	pRedNode.Fill = new SolidColorBrush(Colors.Red);
1132	pRedNode.StrokeThickness = STROKE_NODE;	1132	pRedNode.StrokeThickness = STROKE_NODE;
1133	pRedNode.Data = gGrpRedNode;	1133	pRedNode.Data = gGrpRedNode;
1134		1134
1135	// Setting for path of yellow node	1135	// Setting for path of yellow node
1136	pYellowNode.Stroke = new SolidColorBrush(Colors.Blue);	1136	pYellowNode.Stroke = new SolidColorBrush(Colors.Blue);
1137	pYellowNode.Fill = new SolidColorBrush(Colors.Yellow);	1137	pYellowNode.Fill = new SolidColorBrush(Colors.Yellow);
1138	pYellowNode.StrokeThickness = STROKE_NODE;	1138	pYellowNode.StrokeThickness = STROKE_NODE;
1139	pYellowNode.Data = gGrpYellowNode;	1139	pYellowNode.Data = gGrpYellowNode;
1140		1140
1141	// Setting for path of Blue node	1141	// Setting for path of Blue node
1142	pBlueNode.Stroke = new SolidColorBrush(Colors.Blue);	1142	pBlueNode.Stroke = new SolidColorBrush(Colors.Blue);
1143	pBlueNode.Fill = new SolidColorBrush(Colors.LightBlue);	1143	pBlueNode.Fill = new SolidColorBrush(Colors.LightBlue);
1144	pBlueNode.StrokeThickness = STROKE_NODE;	1144	pBlueNode.StrokeThickness = STROKE_NODE;
1145	pBlueNode.Data = gGrpBlueNode;	1145	pBlueNode.Data = gGrpBlueNode;
1146		1146
1147	// Add paths to canvas	1147	// Add paths to canvas
1148	this.Children.Add(pLine);	1148	this.Children.Add(pLine);
1149	this.Children.Add(pCurverLine);	1149	this.Children.Add(pCurverLine);
1150	this.Children.Add(pRedNode);	1150	this.Children.Add(pRedNode);
1151	this.Children.Add(pYellowNode);	1151	this.Children.Add(pYellowNode);
1152		1152
1153	//this.Children.Add(pNewLine);	1153	//this.Children.Add(pNewLine);
1154	//scheduleCanvas.Children.Add(pScheduleLine);	1154	//scheduleCanvas.Children.Add(pScheduleLine);
1155	}	1155	}
1156		1156
1157	/// <summary>	1157	/// <summary>
1158	/// Clear all route	1158	/// Clear all route
1159	/// </summary>	1159	/// </summary>
1160	public void ClearRoute()	1160	public void ClearRoute()
1161	{	1161	{
1162	isStartDrawRoute = false;	1162	isStartDrawRoute = false;
1163	isGoalDrawRoute = false;	1163	isGoalDrawRoute = false;
1164		1164
1165	gGrpLine.Children.Clear();	1165	gGrpLine.Children.Clear();
1166	gGrpRootLine.Children.Clear();	1166	gGrpRootLine.Children.Clear();
1167	gGrpCurverLine.Children.Clear();	1167	gGrpCurverLine.Children.Clear();
1168	gGrpRedNode.Children.Clear();	1168	gGrpRedNode.Children.Clear();
1169	gGrpYellowNode.Children.Clear();	1169	gGrpYellowNode.Children.Clear();
1170	gGrpBlueNode.Children.Clear();	1170	gGrpBlueNode.Children.Clear();
1171		1171
1172	this.Children.Remove(pLine);	1172	this.Children.Remove(pLine);
1173	this.Children.Remove(pRootLine);	1173	this.Children.Remove(pRootLine);
1174	this.Children.Remove(pCurverLine);	1174	this.Children.Remove(pCurverLine);
1175	this.Children.Remove(pRedNode);	1175	this.Children.Remove(pRedNode);
1176	this.Children.Remove(pYellowNode);	1176	this.Children.Remove(pYellowNode);
1177	this.Children.Remove(pBlueNode);	1177	this.Children.Remove(pBlueNode);
1178	}	1178	}
1179		1179
1180	/// <summary>	1180	/// <summary>
1181	/// Draw line for route	1181	/// Draw line for route
1182	/// </summary>	1182	/// </summary>
1183	/// <param name="startPoint">Start point</param>	1183	/// <param name="startPoint">Start point</param>
1184	/// <param name="endPoint">End point</param>	1184	/// <param name="endPoint">End point</param>
1185	/// <param name="geometryGroup">Geometry Group</param>	1185	/// <param name="geometryGroup">Geometry Group</param>
1186	private void DrawLine(Point startPoint, Point endPoint, GeometryGroup geometryGroup)	1186	private void DrawLine(Point startPoint, Point endPoint, GeometryGroup geometryGroup)
1187	{	1187	{
1188	LineGeometry lineGeometry = new LineGeometry();	1188	LineGeometry lineGeometry = new LineGeometry();
1189	lineGeometry.StartPoint = startPoint;	1189	lineGeometry.StartPoint = startPoint;
1190	lineGeometry.EndPoint = endPoint;	1190	lineGeometry.EndPoint = endPoint;
1191	geometryGroup.Children.Add(lineGeometry);	1191	geometryGroup.Children.Add(lineGeometry);
1192	}	1192	}
1193		1193
1194	/// <summary>	1194	/// <summary>
1195	/// Draw curver line	1195	/// Draw curver line
1196	/// </summary>	1196	/// </summary>
1197	/// <param name="startPoint">Point start curver line</param>	1197	/// <param name="startPoint">Point start curver line</param>
1198	/// <param name="endPoint">Point end curver line</param>	1198	/// <param name="endPoint">Point end curver line</param>
1199	/// <param name="radius">Radius</param>	1199	/// <param name="radius">Radius</param>
1200	/// <param name="geometryGroup">Geometry Group</param>	1200	/// <param name="geometryGroup">Geometry Group</param>
1201	private void DrawCurverLine(Point startPoint, Point endPoint, SweepDirection sweepDirection, GeometryGroup geometryGroup)	1201	private void DrawCurverLine(Point startPoint, Point endPoint, SweepDirection sweepDirection, GeometryGroup geometryGroup)
1202	{	1202	{
1203	PathGeometry pathGeometry = new PathGeometry();	1203	PathGeometry pathGeometry = new PathGeometry();
1204	PathFigure figure = new PathFigure();	1204	PathFigure figure = new PathFigure();
1205	figure.StartPoint = startPoint;	1205	figure.StartPoint = startPoint;
1206	figure.Segments.Add(new ArcSegment(endPoint, new Size(RADIUS_CURVER_LINE, RADIUS_CURVER_LINE), 90, false, sweepDirection, true));	1206	figure.Segments.Add(new ArcSegment(endPoint, new Size(RADIUS_CURVER_LINE, RADIUS_CURVER_LINE), 90, false, sweepDirection, true));
1207	pathGeometry.Figures.Add(figure);	1207	pathGeometry.Figures.Add(figure);
1208	geometryGroup.Children.Add(pathGeometry);	1208	geometryGroup.Children.Add(pathGeometry);
1209	}	1209	}
1210		1210
1211	/// <summary>	1211	/// <summary>
1212	/// Setting node	1212	/// Setting node
1213	/// </summary>	1213	/// </summary>
1214	/// <param name="centerPoit">Position of center node</param>	1214	/// <param name="centerPoit">Position of center node</param>
1215	/// <param name="geometryGroup">Geometry Group</param>	1215	/// <param name="geometryGroup">Geometry Group</param>
1216	private void AddNode(Point centerPoit, GeometryGroup geometryGroup)	1216	private void AddNode(Point centerPoit, GeometryGroup geometryGroup)
1217	{	1217	{
1218	double radius = RADIUS_NODE;	1218	double radius = RADIUS_NODE;
1219	geometryGroup.Children.Add(new EllipseGeometry(centerPoit, radius, radius));	1219	geometryGroup.Children.Add(new EllipseGeometry(centerPoit, radius, radius));
1220	}	1220	}
1221		1221
1222	/// <summary>	1222	/// <summary>
1223	/// Check line is vertical or horizontal	1223	/// Check line is vertical or horizontal
1224	/// </summary>	1224	/// </summary>
1225	/// <param name="line"></param>	1225	/// <param name="line"></param>
1226	/// <returns>true:Vertical, false:Horizontal</returns>	1226	/// <returns>true:Vertical, false:Horizontal</returns>
1227	private bool IsVerticalLine(LineGeometry line)	1227	private bool IsVerticalLine(LineGeometry line)
1228	{	1228	{
1229	if (line.StartPoint.X == line.EndPoint.X)	1229	if (line.StartPoint.X == line.EndPoint.X)
1230	{	1230	{
1231	// Vertical line	1231	// Vertical line
1232	return true;	1232	return true;
1233	}	1233	}
1234		1234
1235	// Horizontal line	1235	// Horizontal line
1236	return false;	1236	return false;
1237	}	1237	}
1238		1238
1239	/// <summary>	1239	/// <summary>
1240	/// Get distance between two point	1240	/// Get distance between two point
1241	/// </summary>	1241	/// </summary>
1242	/// <param name="point1">Point 1</param>	1242	/// <param name="point1">Point 1</param>
1243	/// <param name="point2">Point 2</param>	1243	/// <param name="point2">Point 2</param>
1244	/// <returns>Distance between two point</returns>	1244	/// <returns>Distance between two point</returns>
1245	private double GetDistance(Point point1, Point point2)	1245	private double GetDistance(Point point1, Point point2)
1246	{	1246	{
1247	//pythagorean theorem c^2 = a^2 + b^2	1247	//pythagorean theorem c^2 = a^2 + b^2
1248	//thus c = square root(a^2 + b^2)	1248	//thus c = square root(a^2 + b^2)
1249	double a = (double)(point2.X - point1.X);	1249	double a = (double)(point2.X - point1.X);
1250	double b = (double)(point2.Y - point1.Y);	1250	double b = (double)(point2.Y - point1.Y);
1251		1251
1252	return Math.Sqrt(a * a + b * b);	1252	return Math.Sqrt(a * a + b * b);
1253	}	1253	}
1254		1254
1255	/// <summary>	1255	/// <summary>
1256	/// Check point is valid for draw	1256	/// Check point is valid for draw
1257	/// </summary>	1257	/// </summary>
1258	/// <param name="point">Poit need check</param>	1258	/// <param name="point">Poit need check</param>
1259	/// <returns>true:Valid, false:Invalid</returns>	1259	/// <returns>true:Valid, false:Invalid</returns>
1260	private bool IsValidPoint(Point point)	1260	private bool IsValidPoint(Point point)
1261	{	1261	{
1262	return true;	1262	return true;
1263	}	1263	}
1264		1264
1265	/// <summary>	1265	/// <summary>
1266	/// Display coordinate position	1266	/// Display coordinate position
1267	/// </summary>	1267	/// </summary>
1268	/// <param name="point">Position to display</param>	1268	/// <param name="point">Position to display</param>
1269	private void DisplayCoordinate(Point point)	1269	private void DisplayCoordinate(Point point)
1270	{	1270	{
1271	if (_displayAxiPosition == null)	1271	if (_displayAxiPosition == null)
1272	{	1272	{
1273	_displayAxiPosition = new ucDisplayCoordinate();	1273	_displayAxiPosition = new ucDisplayCoordinate();
1274	this.Children.Add(_displayAxiPosition);	1274	this.Children.Add(_displayAxiPosition);
1275	}	1275	}
1276	_displayAxiPosition.Display(point);	1276	_displayAxiPosition.Display(point);
1277	}	1277	}
1278		1278
1279	#endregion	1279	#endregion
1280		1280
1281	#region Functions for Set Auto Nodes	1281	#region Functions for Set Auto Nodes
1282		1282
1283	/// <summary>	1283	/// <summary>
1284	/// SetAutoNodes	1284	/// SetAutoNodes
1285	/// </summary>	1285	/// </summary>
1286	public void SetAutoNodes()	1286	public void SetAutoNodes()
1287	{	1287	{
1288	double radiusStart = DISTANCE_START_NODES;	1288	double radiusStart = DISTANCE_START_NODES;
1289	double radiusEnd = DISTANCE_END_NODES;	1289	double radiusEnd = DISTANCE_END_NODES;
1290	double radiusCurver = RADIUS_CURVER_LINE;	1290	double radiusCurver = RADIUS_CURVER_LINE;
1291		1291
1292	Point startNode;	1292	Point startNode;
1293	Point endNode;	1293	Point endNode;
1294		1294
1295	gGrpBlueNode.Children.Clear();	1295	gGrpBlueNode.Children.Clear();
1296		1296
1297	if (gGrpLine.Children.Count == 1)	1297	if (gGrpLine.Children.Count == 1)
1298	radiusCurver = radiusEnd;	1298	radiusCurver = radiusEnd;
1299		1299
1300	if (gGrpLine.Children.Count > 0)	1300	if (gGrpLine.Children.Count > 0)
1301	{	1301	{
1302	for (int i = 0; i < gGrpLine.Children.Count; i++)	1302	for (int i = 0; i < gGrpLine.Children.Count; i++)
1303	{	1303	{
1304	LineGeometry lineGeometry = (LineGeometry)gGrpLine.Children[i];	1304	LineGeometry lineGeometry = (LineGeometry)gGrpLine.Children[i];
1305	if (i == 0)	1305	if (i == 0)
1306	{	1306	{
1307	startNode = lineGeometry.EndPoint;	1307	startNode = lineGeometry.EndPoint;
1308	endNode = lineGeometry.StartPoint;	1308	endNode = lineGeometry.StartPoint;
1309	DrawAutoNodes(startNode, endNode, radiusCurver, radiusStart);	1309	DrawAutoNodes(startNode, endNode, radiusCurver, radiusStart);
1310	}	1310	}
1311	else if (i == gGrpLine.Children.Count - 1 && i > 0)	1311	else if (i == gGrpLine.Children.Count - 1 && i > 0)
1312	{	1312	{
1313	startNode = lineGeometry.StartPoint;	1313	startNode = lineGeometry.StartPoint;
1314	endNode = lineGeometry.EndPoint;	1314	endNode = lineGeometry.EndPoint;
1315	DrawAutoNodes(startNode, endNode, radiusCurver, radiusEnd);	1315	DrawAutoNodes(startNode, endNode, radiusCurver, radiusEnd);
1316	}	1316	}
1317	else	1317	else
1318	{	1318	{
1319	startNode = lineGeometry.StartPoint;	1319	startNode = lineGeometry.StartPoint;
1320	endNode = lineGeometry.EndPoint;	1320	endNode = lineGeometry.EndPoint;
1321	DrawAutoNodes(startNode, endNode, radiusCurver, radiusCurver);	1321	DrawAutoNodes(startNode, endNode, radiusCurver, radiusCurver);
1322	}	1322	}
1323	}	1323	}
1324	}	1324	}
1325	}	1325	}
1326		1326
1327		1327
1328	/// <summary>	1328	/// <summary>
1329	/// DrawAutoNodes	1329	/// DrawAutoNodes
1330	/// </summary>	1330	/// </summary>
1331	/// <param name="startNode"></param>	1331	/// <param name="startNode"></param>
1332	/// <param name="endNode"></param>	1332	/// <param name="endNode"></param>
1333	/// <param name="radiusStart"></param>	1333	/// <param name="radiusStart"></param>
1334	/// <param name="radiusEnd"></param>	1334	/// <param name="radiusEnd"></param>
1335	private void DrawAutoNodes(Point startNode, Point endNode, double radiusStart, double radiusEnd)	1335	private void DrawAutoNodes(Point startNode, Point endNode, double radiusStart, double radiusEnd)
1336	{	1336	{
1337	double distance = DISTANCE_AUTO_NODES;	1337	double distance = DISTANCE_AUTO_NODES;
1338	double i;	1338	double i;
1339		1339
1340	Point node;	1340	Point node;
1341		1341
1342	// Get postion of blue node on line	1342	// Get postion of blue node on line
1343	if (startNode.X == endNode.X)	1343	if (startNode.X == endNode.X)
1344	{	1344	{
1345	if (startNode.Y > endNode.Y)	1345	if (startNode.Y > endNode.Y)
1346	{	1346	{
1347	i = startNode.Y - radiusStart;	1347	i = startNode.Y - radiusStart;
1348	if (i - distance > endNode.Y + radiusEnd)	1348	if (i - distance > endNode.Y + radiusEnd)
1349	{	1349	{
1350	do	1350	do
1351	{	1351	{
1352	i = i - distance;	1352	i = i - distance;
1353	node = new Point(endNode.X, i);	1353	node = new Point(endNode.X, i);
1354	// Add node to postion distance 1000mm	1354	// Add node to postion distance 1000mm
1355	AddNode(node, gGrpBlueNode);	1355	AddNode(node, gGrpBlueNode);
1356		1356
1357	} while (i > endNode.Y + radiusEnd + distance);	1357	} while (i > endNode.Y + radiusEnd + distance);
1358	}	1358	}
1359	}	1359	}
1360	else	1360	else
1361	{	1361	{
1362	i = startNode.Y + radiusStart;	1362	i = startNode.Y + radiusStart;
1363	if (i + distance < endNode.Y - radiusEnd)	1363	if (i + distance < endNode.Y - radiusEnd)
1364	{	1364	{
1365	do	1365	do
1366	{	1366	{
1367	i = i + distance;	1367	i = i + distance;
1368	node = new Point(endNode.X, i);	1368	node = new Point(endNode.X, i);
1369	// Add node to postion distance 1000mm	1369	// Add node to postion distance 1000mm
1370	AddNode(node, gGrpBlueNode);	1370	AddNode(node, gGrpBlueNode);
1371	} while (i < endNode.Y - radiusEnd - distance);	1371	} while (i < endNode.Y - radiusEnd - distance);
1372	}	1372	}
1373	}	1373	}
1374	}	1374	}
1375	else	1375	else
1376	{	1376	{
1377	if (startNode.X > endNode.X)	1377	if (startNode.X > endNode.X)
1378	{	1378	{
1379	i = startNode.X - radiusStart;	1379	i = startNode.X - radiusStart;
1380	if (i - distance > endNode.X + radiusEnd)	1380	if (i - distance > endNode.X + radiusEnd)
1381	{	1381	{
1382	do	1382	do
1383	{	1383	{
1384	i = i - distance;	1384	i = i - distance;
1385	node = new Point(i, endNode.Y);	1385	node = new Point(i, endNode.Y);
1386	// Add node to postion distance 1000mm	1386	// Add node to postion distance 1000mm
1387	AddNode(node, gGrpBlueNode);	1387	AddNode(node, gGrpBlueNode);
1388	} while (i > endNode.X + radiusEnd + distance);	1388	} while (i > endNode.X + radiusEnd + distance);
1389	}	1389	}
1390	}	1390	}
1391	else	1391	else
1392	{	1392	{
1393	i = startNode.X + radiusStart;	1393	i = startNode.X + radiusStart;
1394	if (i + distance < endNode.X - radiusEnd)	1394	if (i + distance < endNode.X - radiusEnd)
1395	{	1395	{
1396	do	1396	do
1397	{	1397	{
1398	i = i + distance;	1398	i = i + distance;
1399	node = new Point(i, endNode.Y);	1399	node = new Point(i, endNode.Y);
1400	// Add node to postion distance 1000mm	1400	// Add node to postion distance 1000mm
1401	AddNode(node, gGrpBlueNode);	1401	AddNode(node, gGrpBlueNode);
1402	} while (i < endNode.X - radiusEnd - distance);	1402	} while (i < endNode.X - radiusEnd - distance);
1403	}	1403	}
1404	}	1404	}
1405	}	1405	}
1406		1406
1407	}	1407	}
1408		1408
1409	#endregion	1409	#endregion
1410		1410
1411	#region Functions for Set Free Nodes	1411	#region Functions for Set Free Nodes
1412	/// <summary>	1412	/// <summary>
1413	/// Draw Auto Blue node	1413	/// Draw Auto Blue node
1414	/// </summary>	1414	/// </summary>
1415		1415
1416	public void SetFreeNodes(Point FreeNode, bool RightClick)	1416	public void SetFreeNodes(Point FreeNode, bool RightClick)
1417	{	1417	{
1418	double radiusStart = DISTANCE_START_NODES;	1418	double radiusStart = DISTANCE_START_NODES;
1419	double radiusEnd = DISTANCE_END_NODES;	1419	double radiusEnd = DISTANCE_END_NODES;
1420	double radiusNode = RADIUS_NODE;	1420	double radiusNode = RADIUS_NODE;
1421	double radiusCurver = RADIUS_CURVER_LINE + RADIUS_NODE;	1421	double radiusCurver = RADIUS_CURVER_LINE + RADIUS_NODE;
1422		1422
1423	EllipseGeometry ellipseGeometry;	1423	EllipseGeometry ellipseGeometry;
1424	Point node;	1424	Point node;
1425	bool deleteFlag = false;	1425	bool deleteFlag = false;
1426		1426
1427		1427
1428	if (RightClick)	1428	if (RightClick)
1429	{	1429	{
1430	if (gGrpBlueNode.Children.Count > 0)	1430	if (gGrpBlueNode.Children.Count > 0)
1431	{	1431	{
1432	for (int i = 0; i < gGrpBlueNode.Children.Count; i++)	1432	for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
1433	{	1433	{
1434	ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];	1434	ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
1435	node = ellipseGeometry.Center;	1435	node = ellipseGeometry.Center;
1436	if (FreeNode.X == node.X)	1436	if (FreeNode.X == node.X)
1437	{	1437	{
1438	if (CheckIsNode(FreeNode, node, radiusNode))	1438	if (CheckIsNode(FreeNode, node, radiusNode))
1439	{	1439	{
1440	deleteFlag = true;	1440	deleteFlag = true;
1441	}	1441	}
1442	}	1442	}
1443	else	1443	else
1444	{	1444	{
1445	if (CheckIsNode(FreeNode, node, radiusNode))	1445	if (CheckIsNode(FreeNode, node, radiusNode))
1446	{	1446	{
1447	deleteFlag = true;	1447	deleteFlag = true;
1448	}	1448	}
1449	}	1449	}
1450	if (deleteFlag)	1450	if (deleteFlag)
1451	{	1451	{
1452	MessageBoxResult result = MessageBox.Show("Do You Delete This Node?", "Delete Node", MessageBoxButton.OKCancel);	1452	MessageBoxResult result = MessageBox.Show("Do You Delete This Node?", "Delete Node", MessageBoxButton.OKCancel);
1453	if (result == MessageBoxResult.OK)	1453	if (result == MessageBoxResult.OK)
1454	{	1454	{
1455	gGrpBlueNode.Children.RemoveAt(i);	1455	gGrpBlueNode.Children.RemoveAt(i);
1456		1456
1457	this.Children.Remove(NodeNo[i]);	1457	this.Children.Remove(NodeNo[i]);
1458	return;	1458	return;
1459	}	1459	}
1460	else	1460	else
1461	{	1461	{
1462	return;	1462	return;
1463	}	1463	}
1464	}	1464	}
1465	}	1465	}
1466	}	1466	}
1467	}	1467	}
1468	else	1468	else
1469	{	1469	{
1470		1470
1471	for (int i = 0; i < gGrpBlueNode.Children.Count; i++)	1471	for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
1472	{	1472	{
1473	ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];	1473	ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
1474	node = ellipseGeometry.Center;	1474	node = ellipseGeometry.Center;
1475	bool isEditNode = CheckIsNode(FreeNode, node, RADIUS_NODE);	1475	bool isEditNode = CheckIsNode(FreeNode, node, RADIUS_NODE);
1476		1476
1477	if (isEditNode)	1477	if (isEditNode)
1478	{	1478	{
1479	//EditNode(node);	1479	//EditNode(node);
1480	return;	1480	return;
1481	}	1481	}
1482	}	1482	}
1483		1483
1484		1484
1485	MessageBoxResult result = MessageBox.Show("Do You Want To Add This Node?", "Add Node", MessageBoxButton.OKCancel);	1485	MessageBoxResult result = MessageBox.Show("Do You Want To Add This Node?", "Add Node", MessageBoxButton.OKCancel);
1486	if (result == MessageBoxResult.OK)	1486	if (result == MessageBoxResult.OK)
1487	{	1487	{
1488	AddNode(FreeNode, gGrpBlueNode);	1488	AddNode(FreeNode, gGrpBlueNode);
1489		1489
1490	TextBlock textBlock = new TextBlock();	1490	TextBlock textBlock = new TextBlock();
1491	textBlock.Text = stt.ToString();	1491	textBlock.Text = stt.ToString();
1492	textBlock.FontSize = 17;	1492	textBlock.FontSize = 17;
1493	textBlock.Foreground = new SolidColorBrush(Colors.Red);	1493	textBlock.Foreground = new SolidColorBrush(Colors.Red);
1494	Canvas.SetLeft(textBlock, FreeNode.X - RADIUS_NODE / 2);	1494	Canvas.SetLeft(textBlock, FreeNode.X - RADIUS_NODE / 2);
1495	Canvas.SetTop(textBlock, FreeNode.Y - 1.5 * RADIUS_NODE);	1495	Canvas.SetTop(textBlock, FreeNode.Y - 1.5 * RADIUS_NODE);
1496		1496
1497	this.Children.Add(textBlock);	1497	this.Children.Add(textBlock);
1498	NodeNo.Add(textBlock);	1498	NodeNo.Add(textBlock);
1499		1499
1500	if (stt > 1)	1500	if (stt > 1)
1501	{	1501	{
1502	int tmp = gGrpBlueNode.Children.Count;	1502	int tmp = gGrpBlueNode.Children.Count;
1503		1503
1504	EllipseGeometry elip = (EllipseGeometry)gGrpBlueNode.Children[tmp - 2];	1504	EllipseGeometry elip = (EllipseGeometry)gGrpBlueNode.Children[tmp - 2];
1505	Point node1 = elip.Center;	1505	Point node1 = elip.Center;
1506	elip = (EllipseGeometry)gGrpBlueNode.Children[tmp - 1];	1506	elip = (EllipseGeometry)gGrpBlueNode.Children[tmp - 1];
1507	Point node2 = elip.Center;	1507	Point node2 = elip.Center;
1508	DrawLine(node1, node2, gGrpCurverLine);	1508	DrawLine(node1, node2, gGrpCurverLine);
1509	}	1509	}
1510		1510
1511		1511
1512	stt++;	1512	stt++;
1513	}	1513	}
1514	}	1514	}
1515		1515
1516	if (gGrpLine.Children.Count > 0)	1516	if (gGrpLine.Children.Count > 0)
1517	{	1517	{
1518	for (int i = 0; i < gGrpLine.Children.Count; i++)	1518	for (int i = 0; i < gGrpLine.Children.Count; i++)
1519	{	1519	{
1520	LineGeometry lineGeometry = (LineGeometry)gGrpLine.Children[i];	1520	LineGeometry lineGeometry = (LineGeometry)gGrpLine.Children[i];
1521		1521
1522	// Get postion of node on line	1522	// Get postion of node on line
1523	if (IsVerticalLine(lineGeometry))	1523	if (IsVerticalLine(lineGeometry))
1524	{	1524	{
1525	if (FreeNode.X < lineGeometry.EndPoint.X + radiusNode && FreeNode.X > lineGeometry.EndPoint.X - radiusNode)	1525	if (FreeNode.X < lineGeometry.EndPoint.X + radiusNode && FreeNode.X > lineGeometry.EndPoint.X - radiusNode)
1526	{	1526	{
1527	FreeNode.X = lineGeometry.EndPoint.X;	1527	FreeNode.X = lineGeometry.EndPoint.X;
1528		1528
1529	if (i == 0)	1529	if (i == 0)
1530	{	1530	{
1531	if (CheckFreeNodes(lineGeometry, FreeNode, radiusStart, radiusCurver))	1531	if (CheckFreeNodes(lineGeometry, FreeNode, radiusStart, radiusCurver))
1532	{	1532	{
1533		1533
1534	AddNode(FreeNode, gGrpBlueNode);	1534	AddNode(FreeNode, gGrpBlueNode);
1535	}	1535	}
1536	}	1536	}
1537	else if (i == gGrpLine.Children.Count - 1 && i > 0)	1537	else if (i == gGrpLine.Children.Count - 1 && i > 0)
1538	{	1538	{
1539	if (CheckFreeNodes(lineGeometry, FreeNode, radiusCurver, radiusEnd))	1539	if (CheckFreeNodes(lineGeometry, FreeNode, radiusCurver, radiusEnd))
1540	{	1540	{
1541		1541
1542	AddNode(FreeNode, gGrpBlueNode);	1542	AddNode(FreeNode, gGrpBlueNode);
1543	}	1543	}
1544	}	1544	}
1545	else	1545	else
1546	{	1546	{
1547	if (CheckFreeNodes(lineGeometry, FreeNode, radiusCurver, radiusCurver))	1547	if (CheckFreeNodes(lineGeometry, FreeNode, radiusCurver, radiusCurver))
1548	{	1548	{
1549		1549
1550	AddNode(FreeNode, gGrpBlueNode);	1550	AddNode(FreeNode, gGrpBlueNode);
1551	}	1551	}
1552	}	1552	}
1553		1553
1554	}	1554	}
1555	}	1555	}
1556	else	1556	else
1557	{	1557	{
1558	if (FreeNode.Y < lineGeometry.EndPoint.Y + radiusNode && FreeNode.Y > lineGeometry.EndPoint.Y - radiusNode)	1558	if (FreeNode.Y < lineGeometry.EndPoint.Y + radiusNode && FreeNode.Y > lineGeometry.EndPoint.Y - radiusNode)
1559	{	1559	{
1560	FreeNode.Y = lineGeometry.EndPoint.Y;	1560	FreeNode.Y = lineGeometry.EndPoint.Y;
1561	if (i == 0)	1561	if (i == 0)
1562	{	1562	{
1563	if (CheckFreeNodes(lineGeometry, FreeNode, radiusStart, radiusCurver))	1563	if (CheckFreeNodes(lineGeometry, FreeNode, radiusStart, radiusCurver))
1564	{	1564	{
1565		1565
1566	AddNode(FreeNode, gGrpBlueNode);	1566	AddNode(FreeNode, gGrpBlueNode);
1567	}	1567	}
1568	}	1568	}
1569	else if (i == gGrpLine.Children.Count - 1 && i > 0)	1569	else if (i == gGrpLine.Children.Count - 1 && i > 0)
1570	{	1570	{
1571	if (CheckFreeNodes(lineGeometry, FreeNode, radiusCurver, radiusEnd))	1571	if (CheckFreeNodes(lineGeometry, FreeNode, radiusCurver, radiusEnd))
1572	{	1572	{
1573		1573
1574	AddNode(FreeNode, gGrpBlueNode);	1574	AddNode(FreeNode, gGrpBlueNode);
1575	}	1575	}
1576	}	1576	}
1577	else	1577	else
1578	{	1578	{
1579	if (CheckFreeNodes(lineGeometry, FreeNode, radiusCurver, radiusCurver))	1579	if (CheckFreeNodes(lineGeometry, FreeNode, radiusCurver, radiusCurver))
1580	{	1580	{
1581		1581
1582	AddNode(FreeNode, gGrpBlueNode);	1582	AddNode(FreeNode, gGrpBlueNode);
1583	}	1583	}
1584	}	1584	}
1585		1585
1586	}	1586	}
1587	}	1587	}
1588	}	1588	}
1589	}	1589	}
1590	}	1590	}
1591		1591
1592		1592
1593	public bool CheckFreeNodes(LineGeometry lineNode, Point Freenode, double radiusStart, double radiusEnd)	1593	public bool CheckFreeNodes(LineGeometry lineNode, Point Freenode, double radiusStart, double radiusEnd)
1594	{	1594	{
1595		1595
1596	double distanceFreeNode = DISTANCE_FREE_NODES;	1596	double distanceFreeNode = DISTANCE_FREE_NODES;
1597	double radiusNode = RADIUS_NODE;	1597	double radiusNode = RADIUS_NODE;
1598	EllipseGeometry ellipseGeometry;	1598	EllipseGeometry ellipseGeometry;
1599	Point node;	1599	Point node;
1600		1600
1601	if (IsVerticalLine(lineNode))	1601	if (IsVerticalLine(lineNode))
1602	{	1602	{
1603	if (lineNode.StartPoint.Y < lineNode.EndPoint.Y)	1603	if (lineNode.StartPoint.Y < lineNode.EndPoint.Y)
1604	{	1604	{
1605	if (Freenode.Y < lineNode.StartPoint.Y + radiusStart \|\| Freenode.Y > lineNode.EndPoint.Y - radiusEnd)	1605	if (Freenode.Y < lineNode.StartPoint.Y + radiusStart \|\| Freenode.Y > lineNode.EndPoint.Y - radiusEnd)
1606	{	1606	{
1607	return false;	1607	return false;
1608	}	1608	}
1609	}	1609	}
1610	else	1610	else
1611	{	1611	{
1612	if (Freenode.Y > lineNode.StartPoint.Y - radiusStart \|\| Freenode.Y < lineNode.EndPoint.Y + radiusEnd)	1612	if (Freenode.Y > lineNode.StartPoint.Y - radiusStart \|\| Freenode.Y < lineNode.EndPoint.Y + radiusEnd)
1613	{	1613	{
1614	return false;	1614	return false;
1615	}	1615	}
1616	}	1616	}
1617	}	1617	}
1618	else	1618	else
1619	{	1619	{
1620	if (lineNode.StartPoint.X < lineNode.EndPoint.X)	1620	if (lineNode.StartPoint.X < lineNode.EndPoint.X)
1621	{	1621	{
1622	if (Freenode.X < lineNode.StartPoint.X + radiusStart \|\| Freenode.X > lineNode.EndPoint.X - radiusEnd)	1622	if (Freenode.X < lineNode.StartPoint.X + radiusStart \|\| Freenode.X > lineNode.EndPoint.X - radiusEnd)
1623	{	1623	{
1624	return false;	1624	return false;
1625	}	1625	}
1626	}	1626	}
1627	else	1627	else
1628	{	1628	{
1629	if (Freenode.X > lineNode.StartPoint.X - radiusStart \|\| Freenode.X < lineNode.EndPoint.X + radiusEnd)	1629	if (Freenode.X > lineNode.StartPoint.X - radiusStart \|\| Freenode.X < lineNode.EndPoint.X + radiusEnd)
1630	{	1630	{
1631	return false;	1631	return false;
1632	}	1632	}
1633	}	1633	}
1634	}	1634	}
1635		1635
1636	if (gGrpBlueNode.Children.Count > 0)	1636	if (gGrpBlueNode.Children.Count > 0)
1637	{	1637	{
1638	for (int i = 0; i < gGrpBlueNode.Children.Count; i++)	1638	for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
1639	{	1639	{
1640	ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];	1640	ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
1641	node = ellipseGeometry.Center;	1641	node = ellipseGeometry.Center;
1642	if (Freenode.X == node.X)	1642	if (Freenode.X == node.X)
1643	{	1643	{
1644	if (CheckIsNode(Freenode, node, radiusNode))	1644	if (CheckIsNode(Freenode, node, radiusNode))
1645	{	1645	{
1646	return false;	1646	return false;
1647	}	1647	}
1648	else if (Freenode.Y < node.Y + distanceFreeNode && Freenode.Y > node.Y - distanceFreeNode)	1648	else if (Freenode.Y < node.Y + distanceFreeNode && Freenode.Y > node.Y - distanceFreeNode)
1649	{	1649	{
1650	return false;	1650	return false;
1651	}	1651	}
1652	}	1652	}
1653	else if (Freenode.Y == node.Y)	1653	else if (Freenode.Y == node.Y)
1654	{	1654	{
1655	if (CheckIsNode(Freenode, node, radiusNode))	1655	if (CheckIsNode(Freenode, node, radiusNode))
1656	{	1656	{
1657	return false;	1657	return false;
1658	}	1658	}
1659	else if (Freenode.X < node.X + distanceFreeNode && Freenode.X > node.X - distanceFreeNode)	1659	else if (Freenode.X < node.X + distanceFreeNode && Freenode.X > node.X - distanceFreeNode)
1660	{	1660	{
1661	return false;	1661	return false;
1662	}	1662	}
1663	}	1663	}
1664	}	1664	}
1665	}	1665	}
1666		1666
1667	return true;	1667	return true;
1668	}	1668	}
1669		1669
1670	public bool CheckIsNode(Point FreeNode, Point Node, double radiusNode)	1670	public bool CheckIsNode(Point FreeNode, Point Node, double radiusNode)
1671	{	1671	{
1672	if (FreeNode.X < Node.X + radiusNode && FreeNode.X > Node.X - radiusNode && FreeNode.Y < Node.Y + radiusNode && FreeNode.Y > Node.Y - radiusNode)	1672	if (FreeNode.X < Node.X + radiusNode && FreeNode.X > Node.X - radiusNode && FreeNode.Y < Node.Y + radiusNode && FreeNode.Y > Node.Y - radiusNode)
1673	{	1673	{
1674	return true;	1674	return true;
1675	}	1675	}
1676	return false;	1676	return false;
1677	}	1677	}
1678		1678
1679	#endregion	1679	#endregion
1680		1680
1681	#region Edit Node	1681	#region Edit Node
1682	public void InitNodeInfo_List()	1682	public void InitNodeInfo_List()
1683	{	1683	{
1684	//Reset List	1684	//Reset List
1685	NodeInfo_List = new List<NodeInfo>();	1685	NodeInfo_List = new List<NodeInfo>();
1686		1686
1687	if (gGrpBlueNode.Children.Count > 0)	1687	if (gGrpBlueNode.Children.Count > 0)
1688	{	1688	{
1689	// Get start point	1689	// Get start point
1690	LineGeometry lineGeometry = (LineGeometry)gGrpNewLine.Children[0];	1690	LineGeometry lineGeometry = (LineGeometry)gGrpNewLine.Children[0];
1691	Point startPoint = lineGeometry.StartPoint;	1691	Point startPoint = lineGeometry.StartPoint;
1692		1692
1693	NodeInfo n1 = new NodeInfo();	1693	NodeInfo n1 = new NodeInfo();
1694	n1.X = startPoint.X;	1694	n1.X = startPoint.X;
1695	n1.Y = startPoint.Y;	1695	n1.Y = startPoint.Y;
1696	n1.Mode1 = "";	1696	n1.Mode1 = "";
1697	n1.Mode2 = "";	1697	n1.Mode2 = "";
1698	n1.Mode3 = "";	1698	n1.Mode3 = "";
1699	NodeInfo_List.Add(n1);	1699	NodeInfo_List.Add(n1);
1700		1700
1701	for (int i = 0; i < gGrpBlueNode.Children.Count; i++)	1701	for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
1702	{	1702	{
1703	Point point;	1703	Point point;
1704	EllipseGeometry eGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];	1704	EllipseGeometry eGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
1705	point = eGeometry.Center;	1705	point = eGeometry.Center;
1706		1706
1707	NodeInfo Ninfo = new NodeInfo();	1707	NodeInfo Ninfo = new NodeInfo();
1708	Ninfo.X = point.X;	1708	Ninfo.X = point.X;
1709	Ninfo.Y = point.Y;	1709	Ninfo.Y = point.Y;
1710		1710
1711	Ninfo.Mode1 = "";	1711	Ninfo.Mode1 = "";
1712	Ninfo.Mode2 = "";	1712	Ninfo.Mode2 = "";
1713	Ninfo.Mode3 = "";	1713	Ninfo.Mode3 = "";
1714		1714
1715	NodeInfo_List.Add(Ninfo);	1715	NodeInfo_List.Add(Ninfo);
1716	}	1716	}
1717		1717
1718	// Get end point	1718	// Get end point
1719	lineGeometry = (LineGeometry)gGrpLine.Children[gGrpLine.Children.Count - 1];	1719	lineGeometry = (LineGeometry)gGrpLine.Children[gGrpLine.Children.Count - 1];
1720	Point endPoint = lineGeometry.EndPoint;	1720	Point endPoint = lineGeometry.EndPoint;
1721		1721
1722	NodeInfo n2 = new NodeInfo();	1722	NodeInfo n2 = new NodeInfo();
1723	n2.X = startPoint.X;	1723	n2.X = startPoint.X;
1724	n2.Y = startPoint.Y;	1724	n2.Y = startPoint.Y;
1725	n2.Mode1 = "";	1725	n2.Mode1 = "";
1726	n2.Mode2 = "";	1726	n2.Mode2 = "";
1727	n2.Mode3 = "";	1727	n2.Mode3 = "";
1728	NodeInfo_List.Add(n2);	1728	NodeInfo_List.Add(n2);
1729		1729
1730	//Resort NodeInfo_List From Start to Goal	1730	//Resort NodeInfo_List From Start to Goal
1731	LineGeometry firstLine = (LineGeometry)gGrpLine.Children[0];	1731	LineGeometry firstLine = (LineGeometry)gGrpLine.Children[0];
1732	Point startNode = firstLine.StartPoint;	1732	Point startNode = firstLine.StartPoint;
1733	Point endNode = firstLine.EndPoint;	1733	Point endNode = firstLine.EndPoint;
1734		1734
1735		1735
1736	List<NodeInfo> tmpLst = new List<NodeInfo>();	1736	List<NodeInfo> tmpLst = new List<NodeInfo>();
1737		1737
1738	// Create temp List	1738	// Create temp List
1739	if (startNode.X == endNode.X)	1739	if (startNode.X == endNode.X)
1740	{	1740	{
1741	for (int i = 1; i < NodeInfo_List.Count; i++)	1741	for (int i = 1; i < NodeInfo_List.Count; i++)
1742	{	1742	{
1743	if (NodeInfo_List[i].X != endNode.X)	1743	if (NodeInfo_List[i].X != endNode.X)
1744	{	1744	{
1745	break;	1745	break;
1746	}	1746	}
1747	else	1747	else
1748	{	1748	{
1749	tmpLst.Add(NodeInfo_List[i]);	1749	tmpLst.Add(NodeInfo_List[i]);
1750	}	1750	}
1751	}	1751	}
1752	}	1752	}
1753		1753
1754	if (startNode.Y == endNode.Y)	1754	if (startNode.Y == endNode.Y)
1755	{	1755	{
1756	for (int i = 1; i < NodeInfo_List.Count; i++)	1756	for (int i = 1; i < NodeInfo_List.Count; i++)
1757	{	1757	{
1758	if (NodeInfo_List[i].Y != endNode.Y)	1758	if (NodeInfo_List[i].Y != endNode.Y)
1759	{	1759	{
1760	break;	1760	break;
1761	}	1761	}
1762	else	1762	else
1763	{	1763	{
1764	tmpLst.Add(NodeInfo_List[i]);	1764	tmpLst.Add(NodeInfo_List[i]);
1765	}	1765	}
1766	}	1766	}
1767	}	1767	}
1768		1768
1769	// Sort NodeInfo_List	1769	// Sort NodeInfo_List
1770	for (int i = 0; i < tmpLst.Count; i++)	1770	for (int i = 0; i < tmpLst.Count; i++)
1771	{	1771	{
1772	NodeInfo_List[i + 1] = tmpLst[tmpLst.Count - 1 - i];	1772	NodeInfo_List[i + 1] = tmpLst[tmpLst.Count - 1 - i];
1773	}	1773	}
1774		1774
1775	}	1775	}
1776	}	1776	}
1777		1777
1778		1778
1779	//public void EditNode(Point node_edited)	1779	//public void EditNode(Point node_edited)
1780	//{	1780	//{
1781	// EllipseGeometry ellipseGeometry;	1781	// EllipseGeometry ellipseGeometry;
1782	// Point node;	1782	// Point node;
1783	// double radiusNode = RADIUS_NODE;	1783	// double radiusNode = RADIUS_NODE;
1784		1784
1785	// bool flag = false;	1785	// bool flag = false;
1786		1786
1787	// if (gGrpBlueNode.Children.Count > 0)	1787	// if (gGrpBlueNode.Children.Count > 0)
1788	// {	1788	// {
1789	// for (int i = 0; i < gGrpBlueNode.Children.Count; i++)	1789	// for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
1790	// {	1790	// {
1791	// ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];	1791	// ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
1792	// node = ellipseGeometry.Center;	1792	// node = ellipseGeometry.Center;
1793		1793
1794	// if (CheckIsNode(node_edited, node, radiusNode))	1794	// if (CheckIsNode(node_edited, node, radiusNode))
1795	// {	1795	// {
1796	// flag = true;	1796	// flag = true;
1797	// }	1797	// }
1798		1798
1799	// if (flag)	1799	// if (flag)
1800	// {	1800	// {
1801	// node_edited.X = node.X;	1801	// node_edited.X = node.X;
1802	// node_edited.Y = node.Y;	1802	// node_edited.Y = node.Y;
1803		1803
1804	// // show form edit node	1804	// // show form edit node
1805	// EditNodeWindow edtNodeWindow = new EditNodeWindow();	1805	// EditNodeWindow edtNodeWindow = new EditNodeWindow();
1806	// edtNodeWindow.ShowDialog();	1806	// edtNodeWindow.ShowDialog();
1807		1807
1808	// string result1 = edtNodeWindow._txtMode1;	1808	// string result1 = edtNodeWindow._txtMode1;
1809	// string result2 = edtNodeWindow._txtMode2;	1809	// string result2 = edtNodeWindow._txtMode2;
1810	// string result3 = edtNodeWindow._txtMode3;	1810	// string result3 = edtNodeWindow._txtMode3;
1811	// bool exit = edtNodeWindow._ExitFlg;	1811	// bool exit = edtNodeWindow._ExitFlg;
1812		1812
1813	// if (!exit)	1813	// if (!exit)
1814	// {	1814	// {
1815	// SaveChanged(node_edited.X, node_edited.Y, result1, result2, result3);	1815	// SaveChanged(node_edited.X, node_edited.Y, result1, result2, result3);
1816	// }	1816	// }
1817		1817
1818	// return;	1818	// return;
1819	// }	1819	// }
1820	// }	1820	// }
1821	// }	1821	// }
1822	//}	1822	//}
1823		1823
1824	public void SaveChanged(double x, double y, string st1, string st2, string st3)	1824	public void SaveChanged(double x, double y, string st1, string st2, string st3)
1825	{	1825	{
1826	for (int i = 0; i < NodeInfo_List.Count; i++)	1826	for (int i = 0; i < NodeInfo_List.Count; i++)
1827	{	1827	{
1828	NodeInfo ni = new NodeInfo();	1828	NodeInfo ni = new NodeInfo();
1829	ni = NodeInfo_List[i];	1829	ni = NodeInfo_List[i];
1830		1830
1831	if (ni.X == x && ni.Y == y)	1831	if (ni.X == x && ni.Y == y)
1832	{	1832	{
1833		1833
1834	ni.Mode1 = st1;	1834	ni.Mode1 = st1;
1835	ni.Mode2 = st2;	1835	ni.Mode2 = st2;
1836	ni.Mode3 = st3;	1836	ni.Mode3 = st3;
1837		1837
1838	NodeInfo_List[i] = ni;	1838	NodeInfo_List[i] = ni;
1839	return;	1839	return;
1840	}	1840	}
1841	}	1841	}
1842	}	1842	}
1843		1843
1844		1844
1845	#endregion	1845	#endregion
1846		1846
1847	#region Display RouteInfo	1847	#region Display RouteInfo
1848		1848
1849	public void DspRouteInfo()	1849	public void DspRouteInfo()
1850	{	1850	{
1851	//Clear Route Info Table	1851	//Clear Route Info Table
1852	((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Clear();	1852	((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Clear();
1853		1853
1854	if (NodeInfo_List.Count != 0)	1854	if (NodeInfo_List.Count != 0)
1855	{	1855	{
1856	int _RowIdx = 0;	1856	int _RowIdx = 0;
1857	string _Content = "";	1857	string _Content = "";
1858		1858
1859	for (int i = 0; i < NodeInfo_List.Count; i++)	1859	for (int i = 0; i < NodeInfo_List.Count; i++)
1860	{	1860	{
1861		1861
1862	NodeInfo ni = new NodeInfo();	1862	NodeInfo ni = new NodeInfo();
1863	ni = NodeInfo_List[i];	1863	ni = NodeInfo_List[i];
1864		1864
1865	//column 1	1865	//column 1
1866	if (i == 0)	1866	if (i == 0)
1867	{	1867	{
1868	_Content = "S";	1868	_Content = "S";
1869	}	1869	}
1870	else if (i == NodeInfo_List.Count - 1)	1870	else if (i == NodeInfo_List.Count - 1)
1871	{	1871	{
1872	_Content = "G";	1872	_Content = "G";
1873	}	1873	}
1874	else	1874	else
1875	{	1875	{
1876	_Content = i.ToString();	1876	_Content = i.ToString();
1877	}	1877	}
1878	AddLabeltoGrid(_RowIdx, 0, _Content);	1878	AddLabeltoGrid(_RowIdx, 0, _Content);
1879		1879
1880	//column 2	1880	//column 2
1881	// Display Node's Position	1881	// Display Node's Position
1882	_Content = ni.X + ", " + ni.Y;	1882	_Content = ni.X + ", " + ni.Y;
1883	AddLabeltoGrid(_RowIdx, 1, _Content);	1883	AddLabeltoGrid(_RowIdx, 1, _Content);
1884		1884
1885	// Display Node's Field	1885	// Display Node's Field
1886	if (ni.Mode1 != "" && ni.Mode1 != null)	1886	if (ni.Mode1 != "" && ni.Mode1 != null)
1887	{	1887	{
1888	char delimiterChars = '_';	1888	char delimiterChars = '_';
1889	string[] tmp = ni.Mode1.Split(delimiterChars);	1889	string[] tmp = ni.Mode1.Split(delimiterChars);
1890	foreach (string s in tmp)	1890	foreach (string s in tmp)
1891	{	1891	{
1892	_RowIdx++;	1892	_RowIdx++;
1893	delimiterChars = ':';	1893	delimiterChars = ':';
1894		1894
1895	if (s.Split(delimiterChars)[0] == "Mode")	1895	if (s.Split(delimiterChars)[0] == "Mode")
1896	{	1896	{
1897	double distance = 0;	1897	double distance = 0;
1898	if (i == NodeInfo_List.Count - 1)	1898	if (i == NodeInfo_List.Count - 1)
1899	{	1899	{
1900	distance = 0;	1900	distance = 0;
1901	}	1901	}
1902	else	1902	else
1903	{	1903	{
1904	distance = DistanceCalculate(NodeInfo_List[i].X, NodeInfo_List[i].Y, NodeInfo_List[i + 1].X, NodeInfo_List[i + 1].Y);	1904	distance = DistanceCalculate(NodeInfo_List[i].X, NodeInfo_List[i].Y, NodeInfo_List[i + 1].X, NodeInfo_List[i + 1].Y);
1905	}	1905	}
1906	_Content = "MOVE " + distance.ToString() + "mm";	1906	_Content = "MOVE " + distance.ToString() + "mm";
1907	}	1907	}
1908	else	1908	else
1909	{	1909	{
1910	_Content = s.Split(delimiterChars)[0] + " " + s.Split(delimiterChars)[1];	1910	_Content = s.Split(delimiterChars)[0] + " " + s.Split(delimiterChars)[1];
1911	}	1911	}
1912		1912
1913	AddLabeltoGrid(_RowIdx, 1, _Content);	1913	AddLabeltoGrid(_RowIdx, 1, _Content);
1914	}	1914	}
1915	}	1915	}
1916		1916
1917	if (ni.Mode2 != "" && ni.Mode2 != null)	1917	if (ni.Mode2 != "" && ni.Mode2 != null)
1918	{	1918	{
1919	char delimiterChars = '_';	1919	char delimiterChars = '_';
1920	string[] tmp = ni.Mode2.Split(delimiterChars);	1920	string[] tmp = ni.Mode2.Split(delimiterChars);
1921	foreach (string s in tmp)	1921	foreach (string s in tmp)
1922	{	1922	{
1923	_RowIdx++;	1923	_RowIdx++;
1924	delimiterChars = ':';	1924	delimiterChars = ':';
1925		1925
1926	if (s.Split(delimiterChars)[0] == "Mode")	1926	if (s.Split(delimiterChars)[0] == "Mode")
1927	{	1927	{
1928	double distance = 0;	1928	double distance = 0;
1929	if (i == NodeInfo_List.Count - 1)	1929	if (i == NodeInfo_List.Count - 1)
1930	{	1930	{
1931	distance = 0;	1931	distance = 0;
1932	}	1932	}
1933	else	1933	else
1934	{	1934	{
1935	distance = DistanceCalculate(NodeInfo_List[i].X, NodeInfo_List[i].Y, NodeInfo_List[i + 1].X, NodeInfo_List[i + 1].Y);	1935	distance = DistanceCalculate(NodeInfo_List[i].X, NodeInfo_List[i].Y, NodeInfo_List[i + 1].X, NodeInfo_List[i + 1].Y);
1936	}	1936	}
1937	_Content = "MOVE " + distance.ToString() + "mm";	1937	_Content = "MOVE " + distance.ToString() + "mm";
1938	}	1938	}
1939	else	1939	else
1940	{	1940	{
1941	_Content = s.Split(delimiterChars)[0] + " " + s.Split(delimiterChars)[1];	1941	_Content = s.Split(delimiterChars)[0] + " " + s.Split(delimiterChars)[1];
1942	}	1942	}
1943		1943
1944	AddLabeltoGrid(_RowIdx, 1, _Content);	1944	AddLabeltoGrid(_RowIdx, 1, _Content);
1945	}	1945	}
1946	}	1946	}
1947		1947
1948	if (ni.Mode3 != "" && ni.Mode3 != null)	1948	if (ni.Mode3 != "" && ni.Mode3 != null)
1949	{	1949	{
1950	char delimiterChars = '_';	1950	char delimiterChars = '_';
1951	string[] tmp = ni.Mode3.Split(delimiterChars);	1951	string[] tmp = ni.Mode3.Split(delimiterChars);
1952	foreach (string s in tmp)	1952	foreach (string s in tmp)
1953	{	1953	{
1954	_RowIdx++;	1954	_RowIdx++;
1955	delimiterChars = ':';	1955	delimiterChars = ':';
1956		1956
1957	if (s.Split(delimiterChars)[0] == "Mode")	1957	if (s.Split(delimiterChars)[0] == "Mode")
1958	{	1958	{
1959	double distance = 0;	1959	double distance = 0;
1960	if (i == NodeInfo_List.Count - 1)	1960	if (i == NodeInfo_List.Count - 1)
1961	{	1961	{
1962	distance = 0;	1962	distance = 0;
1963	}	1963	}
1964	else	1964	else
1965	{	1965	{
1966	distance = DistanceCalculate(NodeInfo_List[i].X, NodeInfo_List[i].Y, NodeInfo_List[i + 1].X, NodeInfo_List[i + 1].Y);	1966	distance = DistanceCalculate(NodeInfo_List[i].X, NodeInfo_List[i].Y, NodeInfo_List[i + 1].X, NodeInfo_List[i + 1].Y);
1967	}	1967	}
1968	_Content = "MOVE " + distance.ToString() + "mm";	1968	_Content = "MOVE " + distance.ToString() + "mm";
1969	}	1969	}
1970	else	1970	else
1971	{	1971	{
1972	_Content = s.Split(delimiterChars)[0] + " " + s.Split(delimiterChars)[1];	1972	_Content = s.Split(delimiterChars)[0] + " " + s.Split(delimiterChars)[1];
1973	}	1973	}
1974		1974
1975	AddLabeltoGrid(_RowIdx, 1, _Content);	1975	AddLabeltoGrid(_RowIdx, 1, _Content);
1976	}	1976	}
1977	}	1977	}
1978	_RowIdx++;	1978	_RowIdx++;
1979	}	1979	}
1980	}	1980	}
1981	}	1981	}
1982		1982
1983	public double DistanceCalculate(double _X1, double _Y1, double _X2, double _Y2)	1983	public double DistanceCalculate(double _X1, double _Y1, double _X2, double _Y2)
1984	{	1984	{
1985	double dist = 0;	1985	double dist = 0;
1986		1986
1987	if (_X1 == _X2)	1987	if (_X1 == _X2)
1988	{	1988	{
1989	dist = System.Math.Abs(_Y1 - _Y2) * DISTANCE_RATIO;	1989	dist = System.Math.Abs(_Y1 - _Y2) * DISTANCE_RATIO;
1990	}	1990	}
1991	else if (_Y1 == _Y2)	1991	else if (_Y1 == _Y2)
1992	{	1992	{
1993	dist = System.Math.Abs(_X1 - _X2) * DISTANCE_RATIO;	1993	dist = System.Math.Abs(_X1 - _X2) * DISTANCE_RATIO;
1994	}	1994	}
1995	return dist;	1995	return dist;
1996	}	1996	}
1997		1997
1998	public void AddLabeltoGrid(int RowIdx, int ColIdx, string Content)	1998	public void AddLabeltoGrid(int RowIdx, int ColIdx, string Content)
1999	{	1999	{
2000	//Add Row to Grid	2000	//Add Row to Grid
2001	RowDefinition _rd = new RowDefinition();	2001	RowDefinition _rd = new RowDefinition();
2002	((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.RowDefinitions.Add(_rd);	2002	((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.RowDefinitions.Add(_rd);
2003		2003
2004	// Add data to Grid	2004	// Add data to Grid
2005	Label dynamicLabel = new Label();	2005	Label dynamicLabel = new Label();
2006		2006
2007	dynamicLabel.Content = Content;	2007	dynamicLabel.Content = Content;
2008	dynamicLabel.Margin = new Thickness(0, 0, 0, 0);	2008	dynamicLabel.Margin = new Thickness(0, 0, 0, 0);
2009	dynamicLabel.Foreground = new SolidColorBrush(Colors.Black);	2009	dynamicLabel.Foreground = new SolidColorBrush(Colors.Black);
2010	dynamicLabel.Background = new SolidColorBrush(Colors.White);	2010	dynamicLabel.Background = new SolidColorBrush(Colors.White);
2011	dynamicLabel.BorderBrush = new SolidColorBrush(Colors.LightGray);	2011	dynamicLabel.BorderBrush = new SolidColorBrush(Colors.LightGray);
2012	dynamicLabel.BorderThickness = new Thickness(1);	2012	dynamicLabel.BorderThickness = new Thickness(1);
2013		2013
2014	Grid.SetRow(dynamicLabel, RowIdx);	2014	Grid.SetRow(dynamicLabel, RowIdx);
2015	Grid.SetColumn(dynamicLabel, ColIdx);	2015	Grid.SetColumn(dynamicLabel, ColIdx);
2016	((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Add(dynamicLabel);	2016	((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Add(dynamicLabel);
2017	}	2017	}
2018	#endregion	2018	#endregion
2019		2019
2020		2020
2021	public void CreateGoalPoint()	2021	public void CreateGoalPoint()
2022	{	2022	{
2023	if (isGoalDrawRoute)	2023	if (isGoalDrawRoute)
2024	{	2024	{
2025	return;	2025	return;
2026	}	2026	}
2027		2027
2028	isStartDrawRoute = false;	2028	isStartDrawRoute = false;
2029	if (_goalPoint == null)	2029	if (_goalPoint == null)
2030	{	2030	{
2031	_goalPoint = new ucStartEndButton();	2031	_goalPoint = new ucStartEndButton();
2032	_goalPoint.btnWidth = 50.0;	2032	_goalPoint.btnWidth = 50.0;
2033	_goalPoint.btnHeight = 50.0;	2033	_goalPoint.btnHeight = 50.0;
2034	_goalPoint.buttText = "G";	2034	_goalPoint.buttText = "G";
2035	Canvas.SetLeft(_goalPoint, 675);	2035	Canvas.SetLeft(_goalPoint, 675);
2036	Canvas.SetTop(_goalPoint, 75);	2036	Canvas.SetTop(_goalPoint, 75);
2037	this.Children.Add(_goalPoint);	2037	this.Children.Add(_goalPoint);
2038	}	2038	}
2039	}	2039	}
2040		2040
2041	public void CreateStartPoint()	2041	public void CreateStartPoint()
2042	{	2042	{
2043	if (isGoalDrawRoute)	2043	if (isGoalDrawRoute)
2044	{	2044	{
2045	return;	2045	return;
2046	}	2046	}
2047		2047
2048	isStartDrawRoute = false;	2048	isStartDrawRoute = false;
2049	if (_startPoint == null)	2049	if (_startPoint == null)
2050	{	2050	{
2051	_startPoint = new ucStartEndButton();	2051	_startPoint = new ucStartEndButton();
2052	_startPoint.btnWidth = 50.0;	2052	_startPoint.btnWidth = 50.0;
2053	_startPoint.btnHeight = 50.0;	2053	_startPoint.btnHeight = 50.0;
2054	_startPoint.buttText = "S";	2054	_startPoint.buttText = "S";
2055	Canvas.SetLeft(_startPoint, 75);	2055	Canvas.SetLeft(_startPoint, 75);
2056	Canvas.SetTop(_startPoint, 675);	2056	Canvas.SetTop(_startPoint, 675);
2057	this.Children.Add(_startPoint);	2057	this.Children.Add(_startPoint);
2058	}	2058	}
2059	}	2059	}
2060		2060
2061		2061
2062	#region Draw New FreeNode	2062	#region Draw New FreeNode
2063		2063
2064	/// <summary>	2064	/// <summary>
2065	/// Draw Auto Blue node	2065	/// Draw Auto Blue node
2066	/// </summary>	2066	/// </summary>
2067		2067
2068		2068
2069	public void NewSetFreeNodes(Point FreeNode, bool RightClick)	2069	public void NewSetFreeNodes(Point FreeNode, bool RightClick)
2070	{	2070	{
2071	double radiusNode = RADIUS_NODE;	2071	double radiusNode = RADIUS_NODE;
2072		2072
2073	EllipseGeometry ellipseGeometry;	2073	EllipseGeometry ellipseGeometry;
2074	Point node;	2074	Point node;
2075	bool deleteFlag = false;	2075	bool deleteFlag = false;
2076		2076
2077		2077
2078	if (RightClick)	2078	if (RightClick)
2079	{	2079	{
2080	if (gGrpBlueNode.Children.Count > 0)	2080	if (gGrpBlueNode.Children.Count > 0)
2081	{	2081	{
2082	for (int i = 0; i < gGrpBlueNode.Children.Count; i++)	2082	for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
2083	{	2083	{
2084	ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];	2084	ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
2085	node = ellipseGeometry.Center;	2085	node = ellipseGeometry.Center;
2086	if (FreeNode.X == node.X)	2086	if (FreeNode.X == node.X)
2087	{	2087	{
2088	if (CheckIsNode(FreeNode, node, radiusNode))	2088	if (CheckIsNode(FreeNode, node, radiusNode))
2089	{	2089	{
2090	deleteFlag = true;	2090	deleteFlag = true;
2091	}	2091	}
2092	}	2092	}
2093	else	2093	else
2094	{	2094	{
2095	if (CheckIsNode(FreeNode, node, radiusNode))	2095	if (CheckIsNode(FreeNode, node, radiusNode))
2096	{	2096	{
2097	deleteFlag = true;	2097	deleteFlag = true;
2098	}	2098	}
2099	}	2099	}
2100	if (deleteFlag)	2100	if (deleteFlag)
2101	{	2101	{
2102	MessageBoxResult result = MessageBox.Show("Do You Delete This Node?", "Delete Node", MessageBoxButton.OKCancel);	2102	MessageBoxResult result = MessageBox.Show("Do You Delete This Node?", "Delete Node", MessageBoxButton.OKCancel);
2103	if (result == MessageBoxResult.OK)	2103	if (result == MessageBoxResult.OK)
2104	{	2104	{
2105	//Call Function Delete Node	2105	//Call Function Delete Node
2106	DeleteNode(i);	2106	DeleteNode(i);
2107		2107
2108	return;	2108	return;
2109	}	2109	}
2110	else	2110	else
2111	{	2111	{
2112	return;	2112	return;
2113	}	2113	}
2114	}	2114	}
2115	}	2115	}
2116	}	2116	}
2117	}	2117	}
2118	else	2118	else
2119	{	2119	{
2120	//Check EditNode State	2120	//Check EditNode State
2121	for (int i = 0; i < gGrpBlueNode.Children.Count; i++)	2121	for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
2122	{	2122	{
2123	ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];	2123	ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
2124	node = ellipseGeometry.Center;	2124	node = ellipseGeometry.Center;
2125	bool isEditNode = CheckIsNode(FreeNode, node, RADIUS_NODE);	2125	bool isEditNode = CheckIsNode(FreeNode, node, RADIUS_NODE);
2126		2126
2127	if (isEditNode)	2127	if (isEditNode)
2128	{	2128	{
2129	NewEditNode(node);	2129	NewEditNode(node);
2130	NewDspRouteInfo();	2130	NewDspRouteInfo();
2131	return;	2131	return;
2132	}	2132	}
2133	}	2133	}
2134		2134
2135		2135
2136	MessageBoxResult result = MessageBox.Show("Do You Want To Add This Node?", "Add Node", MessageBoxButton.OKCancel);	2136	MessageBoxResult result = MessageBox.Show("Do You Want To Add This Node?", "Add Node", MessageBoxButton.OKCancel);
2137	if (result == MessageBoxResult.OK)	2137	if (result == MessageBoxResult.OK)
2138	{	2138	{
2139	AddNode(FreeNode, gGrpBlueNode);	2139	AddNode(FreeNode, gGrpBlueNode);
2140		2140
2141	TextBlock textBlock = new TextBlock();	2141	TextBlock textBlock = new TextBlock();
2142	textBlock.Text = stt.ToString();	2142	textBlock.Text = stt.ToString();
2143	textBlock.FontSize = 35;	2143	textBlock.FontSize = 35;
2144	textBlock.VerticalAlignment = VerticalAlignment.Center;	2144	textBlock.VerticalAlignment = VerticalAlignment.Center;
2145	textBlock.HorizontalAlignment = HorizontalAlignment.Center;	2145	textBlock.HorizontalAlignment = HorizontalAlignment.Center;
2146	textBlock.Foreground = new SolidColorBrush(Colors.Red);	2146	textBlock.Foreground = new SolidColorBrush(Colors.Red);
2147		2147
2148	Canvas.SetLeft(textBlock, FreeNode.X - RADIUS_NODE / 2);	2148	Canvas.SetLeft(textBlock, FreeNode.X - RADIUS_NODE / 2);
2149	Canvas.SetTop(textBlock, FreeNode.Y - 1.5 * RADIUS_NODE);	2149	Canvas.SetTop(textBlock, FreeNode.Y - 1.5 * RADIUS_NODE);
2150		2150
2151		2151
2152	this.Children.Add(textBlock);	2152	this.Children.Add(textBlock);
2153	NodeNo.Add(textBlock);	2153	NodeNo.Add(textBlock);
2154		2154
2155	if (stt > 1)	2155	if (stt > 1)
2156	{	2156	{
2157	int tmp = gGrpBlueNode.Children.Count;	2157	int tmp = gGrpBlueNode.Children.Count;
2158		2158
2159	EllipseGeometry elip = (EllipseGeometry)gGrpBlueNode.Children[tmp - 2];	2159	EllipseGeometry elip = (EllipseGeometry)gGrpBlueNode.Children[tmp - 2];
2160	Point node1 = elip.Center;	2160	Point node1 = elip.Center;
2161	elip = (EllipseGeometry)gGrpBlueNode.Children[tmp - 1];	2161	elip = (EllipseGeometry)gGrpBlueNode.Children[tmp - 1];
2162	Point node2 = elip.Center;	2162	Point node2 = elip.Center;
2163	DrawLine(node1, node2, gGrpNewLine);	2163	DrawLine(node1, node2, gGrpNewLine);
2164		2164
2165		2165
2166	this.Children.Remove(pBlueNode);	2166	this.Children.Remove(pBlueNode);
2167	for (int i = 0; i < tmp; i++)	2167	for (int i = 0; i < tmp; i++)
2168	{	2168	{
2169	this.Children.Remove(NodeNo[i]);	2169	this.Children.Remove(NodeNo[i]);
2170	}	2170	}
2171		2171
2172	this.Children.Add(pBlueNode);	2172	this.Children.Add(pBlueNode);
2173	for (int i = 0; i < tmp; i++)	2173	for (int i = 0; i < tmp; i++)
2174	{	2174	{
2175	this.Children.Add(NodeNo[i]);	2175	this.Children.Add(NodeNo[i]);
2176	}	2176	}
2177	}	2177	}
2178		2178
2179	stt++;	2179	stt++;
2180	NewInitNodeInfo_List();	2180	NewInitNodeInfo_List();
2181	NewDspRouteInfo();	2181	NewDspRouteInfo();
2182	}	2182	}
2183	}	2183	}
2184	}	2184	}
2185		2185
2186	public void DeleteNode(int i)	2186	public void DeleteNode(int i)
2187	{	2187	{
2188	//DrawLine(Point startPoint, Point endPoint, GeometryGroup geometryGroup)	2188	//DrawLine(Point startPoint, Point endPoint, GeometryGroup geometryGroup)
2189		2189
2190	LineGeometry lineGeometry = new LineGeometry();	2190	LineGeometry lineGeometry = new LineGeometry();
2191	EllipseGeometry ellip;	2191	EllipseGeometry ellip;
2192		2192
2193	//check delete last node	2193	//check delete last node
2194	if (i == gGrpBlueNode.Children.Count - 1)	2194	if (i == gGrpBlueNode.Children.Count - 1)
2195	{	2195	{
2196	// delete line	2196	// delete line
2197	if (gGrpNewLine.Children.Count > 0)	2197	if (gGrpNewLine.Children.Count > 0)
2198	{	2198	{
2199	gGrpNewLine.Children.RemoveAt(i - 1);	2199	gGrpNewLine.Children.RemoveAt(i - 1);
2200	}	2200	}
2201		2201
2202	// delete ucNode	2202	// delete ucNode
2203	ucNode _ucNode = new ucNode();	2203	ucNode _ucNode = new ucNode();
2204	_ucNode = ucNode_Lst[i];	2204	_ucNode = ucNode_Lst[i];
2205	this.Children.Remove(_ucNode);	2205	this.Children.Remove(_ucNode);
2206	ucNode_Lst.RemoveAt(i);	2206	ucNode_Lst.RemoveAt(i);
2207		2207
2208	// delete node	2208	// delete node
2209	gGrpBlueNode.Children.RemoveAt(i);	2209	gGrpBlueNode.Children.RemoveAt(i);
2210	NewNodeInfo_List.RemoveAt(i);	2210	NewNodeInfo_List.RemoveAt(i);
2211		2211
2212	}	2212	}
2213	else	2213	else
2214	{	2214	{
2215	//delete all line and remove Point at 'i'	2215	//delete all line and remove Point at 'i'
2216	gGrpNewLine.Children.Clear();	2216	gGrpNewLine.Children.Clear();
2217	this.Children.Remove(pNewLine);	2217	this.Children.Remove(pNewLine);
2218	gGrpBlueNode.Children.RemoveAt(i);	2218	gGrpBlueNode.Children.RemoveAt(i);
2219		2219
2220	//redraw line	2220	//redraw line
2221	for (int j = 0; j < gGrpBlueNode.Children.Count - 1; j++)	2221	for (int j = 0; j < gGrpBlueNode.Children.Count - 1; j++)
2222	{	2222	{
2223	ellip = (EllipseGeometry)gGrpBlueNode.Children[j];	2223	ellip = (EllipseGeometry)gGrpBlueNode.Children[j];
2224	Point node1 = ellip.Center;	2224	Point node1 = ellip.Center;
2225	ellip = (EllipseGeometry)gGrpBlueNode.Children[j + 1];	2225	ellip = (EllipseGeometry)gGrpBlueNode.Children[j + 1];
2226	Point node2 = ellip.Center;	2226	Point node2 = ellip.Center;
2227	DrawLine(node1, node2, gGrpNewLine);	2227	DrawLine(node1, node2, gGrpNewLine);
2228	}	2228	}
2229		2229
2230	this.Children.Add(pNewLine);	2230	this.Children.Add(pNewLine);
2231		2231
2232	//remove ucNode	2232	//remove ucNode
2233	for (int j = ucNode_Lst.Count - 1; j > i; j--)	2233	for (int j = ucNode_Lst.Count - 1; j > i; j--)
2234	{	2234	{
2235	ucNode_Lst[j].txtNode = ucNode_Lst[j - 1].txtNode;	2235	ucNode_Lst[j].txtNode = ucNode_Lst[j - 1].txtNode;
2236	}	2236	}
2237	this.Children.Remove(ucNode_Lst[i]);	2237	this.Children.Remove(ucNode_Lst[i]);
2238	ucNode_Lst.RemoveAt(i);	2238	ucNode_Lst.RemoveAt(i);
2239		2239
2240	//redraw ucNode	2240	//redraw ucNode
2241	for (int k = 0; k < ucNode_Lst.Count; k++)	2241	for (int k = 0; k < ucNode_Lst.Count; k++)
2242	{	2242	{
2243	this.Children.Remove(ucNode_Lst[k]);	2243	this.Children.Remove(ucNode_Lst[k]);
2244	this.Children.Add(ucNode_Lst[k]);	2244	this.Children.Add(ucNode_Lst[k]);
2245	}	2245	}
2246	}	2246	}
2247		2247
2248	//NewInitNodeInfo_List();	2248	//NewInitNodeInfo_List();
2249		2249
2250	Lst_Node_tmp.RemoveAt(i);	2250	Lst_Node_tmp.RemoveAt(i);
2251	NewDspRouteInfo();	2251	NewDspRouteInfo();
2252	stt--;	2252	stt--;
2253		2253
2254	}	2254	}
2255		2255
2256	public void ReDrawAllNode()	2256	public void ReDrawAllNode()
2257	{	2257	{
2258	LineGeometry lineGeometry = new LineGeometry();	2258	LineGeometry lineGeometry = new LineGeometry();
2259	EllipseGeometry ellip;	2259	EllipseGeometry ellip;
2260	//delete all line	2260	//delete all line
2261	gGrpNewLine.Children.Clear();	2261	gGrpNewLine.Children.Clear();
2262	this.Children.Remove(pNewLine);	2262	this.Children.Remove(pNewLine);
2263		2263
2264	//redraw line	2264	//redraw line
2265	for (int j = 0; j < gGrpBlueNode.Children.Count - 1; j++)	2265	for (int j = 0; j < gGrpBlueNode.Children.Count - 1; j++)
2266	{	2266	{
2267	ellip = (EllipseGeometry)gGrpBlueNode.Children[j];	2267	ellip = (EllipseGeometry)gGrpBlueNode.Children[j];
2268	Point node1 = ellip.Center;	2268	Point node1 = ellip.Center;
2269	ellip = (EllipseGeometry)gGrpBlueNode.Children[j + 1];	2269	ellip = (EllipseGeometry)gGrpBlueNode.Children[j + 1];
2270	Point node2 = ellip.Center;	2270	Point node2 = ellip.Center;
2271	DrawLine(node1, node2, gGrpNewLine);	2271	DrawLine(node1, node2, gGrpNewLine);
2272	}	2272	}
2273		2273
2274	this.Children.Add(pNewLine);	2274	this.Children.Add(pNewLine);
2275		2275
2276		2276
2277	//redraw ucNode	2277	//redraw ucNode
2278	for (int k = 0; k < ucNode_Lst.Count; k++)	2278	for (int k = 0; k < ucNode_Lst.Count; k++)
2279	{	2279	{
2280	this.Children.Remove(ucNode_Lst[k]);	2280	this.Children.Remove(ucNode_Lst[k]);
2281	this.Children.Add(ucNode_Lst[k]);	2281	this.Children.Add(ucNode_Lst[k]);
2282	}	2282	}
2283		2283
2284	//backup DB	2284	//backup DB
2285	CreateVehicleNode();	2285	CreateVehicleNode();
2286	}	2286	}
2287		2287
2288		2288
2289	public void NewInitNodeInfo_List()	2289	public void NewInitNodeInfo_List()
2290	{	2290	{
2291	//Reset List	2291	//Reset List
2292	//NewNodeInfo_List = new List<NewNodeInfo>();	2292	//NewNodeInfo_List = new List<NewNodeInfo>();
2293		2293
2294	if (gGrpBlueNode.Children.Count > 0)	2294	if (gGrpBlueNode.Children.Count > 0)
2295	{	2295	{
2296	//for (int i = 0; i < gGrpBlueNode.Children.Count; i++)	2296	//for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
2297	//{	2297	//{
2298	int i = gGrpBlueNode.Children.Count - 1;	2298	int i = gGrpBlueNode.Children.Count - 1;
2299	Point point;	2299	Point point;
2300	EllipseGeometry eGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];	2300	EllipseGeometry eGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
2301	point = eGeometry.Center;	2301	point = eGeometry.Center;
2302		2302
2303	NewNodeInfo Ninfo = new NewNodeInfo();	2303	NewNodeInfo Ninfo = new NewNodeInfo();
2304	Ninfo.X = point.X;	2304	Ninfo.X = point.X;
2305	Ninfo.Y = point.Y;	2305	Ninfo.Y = point.Y;
2306		2306
2307	Ninfo.Mode = "";	2307	Ninfo.Mode = "";
2308		2308
2309	NewNodeInfo_List.Add(Ninfo);	2309	NewNodeInfo_List.Add(Ninfo);
2310	//}	2310	//}
2311		2311
2312	}	2312	}
2313	}	2313	}
2314		2314
2315	public void NewEditNode(Point node_edited)	2315	public void NewEditNode(Point node_edited)
2316	{	2316	{
2317	EllipseGeometry ellipseGeometry;	2317	EllipseGeometry ellipseGeometry;
2318	Point node;	2318	Point node;
2319	double radiusNode = RADIUS_NODE;	2319	double radiusNode = RADIUS_NODE;
2320		2320
2321	bool flag = false;	2321	bool flag = false;
2322		2322
2323	if (gGrpBlueNode.Children.Count > 0)	2323	if (gGrpBlueNode.Children.Count > 0)
2324	{	2324	{
2325	for (int i = 0; i < gGrpBlueNode.Children.Count; i++)	2325	for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
2326	{	2326	{
2327	ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];	2327	ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
2328	node = ellipseGeometry.Center;	2328	node = ellipseGeometry.Center;
2329		2329
2330	if (CheckIsNode(node_edited, node, radiusNode))	2330	if (CheckIsNode(node_edited, node, radiusNode))
2331	{	2331	{
2332	flag = true;	2332	flag = true;
2333	}	2333	}
2334		2334
2335	if (flag)	2335	if (flag)
2336	{	2336	{
2337	node_edited.X = node.X;	2337	node_edited.X = node.X;
2338	node_edited.Y = node.Y;	2338	node_edited.Y = node.Y;
2339		2339
2340	// show form edit node	2340	// show form edit node
2341	EditNodeWindow edtNodeWindow = new EditNodeWindow();	2341	EditNodeWindow edtNodeWindow = new EditNodeWindow();
2342	List<ListNodeInfo> lst_tmpdfd = new List<ListNodeInfo>();	2342	List<ListNodeInfo> lst_tmpdfd = new List<ListNodeInfo>();
2343		2343
2344	if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Count > 0)	2344	if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Count > 0)
2345	{	2345	{
2346	for (int k = 0; k < ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Count; k++)	2346	for (int k = 0; k < ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Count; k++)
2347	{	2347	{
2348	double X = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].pointMap_X;	2348	double X = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].pointMap_X;
2349	double Y = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].pointMap_Y;	2349	double Y = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].pointMap_Y;
2350		2350
2351	Point node_editedActual = new Point();	2351	Point node_editedActual = new Point();
2352		2352
2353	node_editedActual.X = ConvertPointDisplayToActual(node_edited.X, Scale_X, PointMapStart_X);	2353	node_editedActual.X = ConvertPointDisplayToActual(node_edited.X, Scale_X, PointMapStart_X);
2354	node_editedActual.Y = ConvertPointDisplayToActual(node_edited.Y, Scale_Y, PointMapStart_Y);	2354	node_editedActual.Y = ConvertPointDisplayToActual(node_edited.Y, Scale_Y, PointMapStart_Y);
2355		2355
2356		2356
2357	//if (node_edited.X == X && node_edited.Y == Y)	2357	//if (node_edited.X == X && node_edited.Y == Y)
2358	if (node_editedActual.X == X && node_editedActual.Y == Y)	2358	if (node_editedActual.X == X && node_editedActual.Y == Y)
2359	{	2359	{
2360	if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo.Count > 0)	2360	if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo.Count > 0)
2361	{	2361	{
2362	for (int m = 0; m < ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo.Count; m++)	2362	for (int m = 0; m < ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo.Count; m++)
2363	{	2363	{
2364	ListNodeInfo InputNodeInfo = new ListNodeInfo();	2364	ListNodeInfo InputNodeInfo = new ListNodeInfo();
2365	InputNodeInfo.Mode = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo[m].Mode;	2365	InputNodeInfo.Mode = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo[m].Mode;
2366	InputNodeInfo.Speed = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo[m].Speed;	2366	InputNodeInfo.Speed = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo[m].Speed;
2367	InputNodeInfo.Angle = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo[m].Angle;	2367	InputNodeInfo.Angle = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo[m].Angle;
2368	InputNodeInfo.Height = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo[m].Height;	2368	InputNodeInfo.Height = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo[m].Height;
2369	InputNodeInfo.ModeSelected = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo[m].ModeSelected;	2369	InputNodeInfo.ModeSelected = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo[m].ModeSelected;
2370	lst_tmpdfd.Add(InputNodeInfo);	2370	lst_tmpdfd.Add(InputNodeInfo);
2371	}	2371	}
2372		2372
2373	edtNodeWindow.NodeInf_List = lst_tmpdfd;	2373	edtNodeWindow.NodeInf_List = lst_tmpdfd;
2374		2374
2375	}	2375	}
2376	edtNodeWindow.NameNode = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].nameNode;	2376	edtNodeWindow.NameNode = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].nameNode;
2377	edtNodeWindow.LAT = X.ToString(); ;	2377	edtNodeWindow.LAT = X.ToString(); ;
2378	edtNodeWindow.LOC = Y.ToString();	2378	edtNodeWindow.LOC = Y.ToString();
2379		2379
2380	}	2380	}
2381	}	2381	}
2382	}	2382	}
2383		2383
2384	edtNodeWindow.ShowDialog();	2384	edtNodeWindow.ShowDialog();
2385		2385
2386	//Save NameNode	2386	//Save NameNode
2387	string strNameNode = edtNodeWindow.NameNode;	2387	string strNameNode = edtNodeWindow.NameNode;
2388	ListNameNode nmNode = new ListNameNode();	2388	ListNameNode nmNode = new ListNameNode();
2389		2389
2390	nmNode.X = node.X;	2390	nmNode.X = node.X;
2391	nmNode.Y = node.Y;	2391	nmNode.Y = node.Y;
2392	nmNode.nameNode = strNameNode;	2392	nmNode.nameNode = strNameNode;
2393		2393
2394	NameNode_List[i] = nmNode;	2394	NameNode_List[i] = nmNode;
2395		2395
2396		2396
2397	ucNode _ucNode = new ucNode();	2397	ucNode _ucNode = new ucNode();
2398	_ucNode = ucNode_Lst[i];	2398	_ucNode = ucNode_Lst[i];
2399	this.Children.Remove(_ucNode);	2399	this.Children.Remove(_ucNode);
2400	ucNode_Lst.RemoveAt(i);	2400	ucNode_Lst.RemoveAt(i);
2401		2401
2402	string color = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[i].color;	2402	string color = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[i].color;
2403	CreateMapNode(node, i, color, strNameNode);	2403	CreateMapNode(node, i, color, strNameNode);
2404		2404
2405		2405
2406		2406
2407		2407
2408		2408
2409		2409
2410	string result = edtNodeWindow._txtMode;	2410	string result = edtNodeWindow._txtMode;
2411		2411
2412	List<ListNodeInfo> lst_tmp = edtNodeWindow.NodeInf_List;	2412	List<ListNodeInfo> lst_tmp = edtNodeWindow.NodeInf_List;
2413	Lst_Node_tmp[i].NodeInfo_tmp.Clear();	2413	Lst_Node_tmp[i].NodeInfo_tmp.Clear();
2414		2414
2415	for (int j = 0; j < lst_tmp.Count; j++)	2415	for (int j = 0; j < lst_tmp.Count; j++)
2416	{	2416	{
2417		2417
2418	ListNodeInfo ni = new ListNodeInfo();	2418	ListNodeInfo ni = new ListNodeInfo();
2419	ni = lst_tmp[j];	2419	ni = lst_tmp[j];
2420		2420
2421	Lst_Node_tmp[i].NodeInfo_tmp.Add(ni);	2421	Lst_Node_tmp[i].NodeInfo_tmp.Add(ni);
2422	}	2422	}
2423		2423
2424		2424
2425	//backup DB	2425	//backup DB
2426	CreateVehicleNode();	2426	CreateVehicleNode();
2427		2427
2428	bool exit = edtNodeWindow._ExitFlg;	2428	bool exit = edtNodeWindow._ExitFlg;
2429		2429
2430	if (!exit)	2430	if (!exit)
2431	{	2431	{
2432	NewSaveChanged(node_edited.X, node_edited.Y, result);	2432	NewSaveChanged(node_edited.X, node_edited.Y, result);
2433	}	2433	}
2434		2434
2435	return;	2435	return;
2436	}	2436	}
2437	}	2437	}
2438	}	2438	}
2439	}	2439	}
2440		2440
2441	//Save Node's Data Edited	2441	//Save Node's Data Edited
2442	public void NewSaveChanged(double x, double y, string st)	2442	public void NewSaveChanged(double x, double y, string st)
2443	{	2443	{
2444	for (int i = 0; i < NewNodeInfo_List.Count; i++)	2444	for (int i = 0; i < NewNodeInfo_List.Count; i++)
2445	{	2445	{
2446	NewNodeInfo ni = new NewNodeInfo();	2446	NewNodeInfo ni = new NewNodeInfo();
2447	ni = NewNodeInfo_List[i];	2447	ni = NewNodeInfo_List[i];
2448		2448
2449	if (ni.X == x && ni.Y == y)	2449	if (ni.X == x && ni.Y == y)
2450	{	2450	{
2451	ni.Mode = st;	2451	ni.Mode = st;
2452		2452
2453	NewNodeInfo_List[i] = ni;	2453	NewNodeInfo_List[i] = ni;
2454	return;	2454	return;
2455	}	2455	}
2456	}	2456	}
2457	}	2457	}
2458		2458
2459	public void NewDspRouteInfo()	2459	public void NewDspRouteInfo()
2460	{	2460	{
2461	//Clear Route Info Table	2461	//Clear Route Info Table
2462	((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Clear();	2462	((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Clear();
2463	int _RowIdx = 0;	2463	int _RowIdx = 0;
2464	string _Content = "";	2464	string _Content = "";
2465		2465
2466	if (Lst_Node_tmp.Count != 0)	2466	if (Lst_Node_tmp.Count != 0)
2467	{	2467	{
2468	for (int i = 0; i < Lst_Node_tmp.Count; i++)	2468	for (int i = 0; i < Lst_Node_tmp.Count; i++)
2469	{	2469	{
2470	//column 1 : node index	2470	//column 1 : node index
2471	_Content = (i + 1).ToString();	2471	_Content = (i + 1).ToString();
2472	AddLabeltoGrid(_RowIdx, 0, _Content);	2472	AddLabeltoGrid(_RowIdx, 0, _Content);
2473		2473
2474	//column 2	2474	//column 2
2475	// Display Node's Position	2475	// Display Node's Position
2476	_Content = "LAT " + Lst_Node_tmp[i].pointMap_X;	2476	_Content = "LAT " + Lst_Node_tmp[i].pointMap_X;
2477	AddLabeltoGrid(_RowIdx, 1, _Content);	2477	AddLabeltoGrid(_RowIdx, 1, _Content);
2478	_RowIdx++;	2478	_RowIdx++;
2479		2479
2480	_Content = "LOC " + Lst_Node_tmp[i].pointMap_Y;	2480	_Content = "LOC " + Lst_Node_tmp[i].pointMap_Y;
2481	AddLabeltoGrid(_RowIdx, 1, _Content);	2481	AddLabeltoGrid(_RowIdx, 1, _Content);
2482		2482
2483	// Display Node's Field	2483	// Display Node's Field
2484		2484
2485	if (Lst_Node_tmp[i].NodeInfo_tmp.Count != 0)	2485	if (Lst_Node_tmp[i].NodeInfo_tmp.Count != 0)
2486	{	2486	{
2487	foreach (ListNodeInfo ni in Lst_Node_tmp[i].NodeInfo_tmp)	2487	foreach (ListNodeInfo ni in Lst_Node_tmp[i].NodeInfo_tmp)
2488	{	2488	{
2489	if (ni.Speed != 0 && ni.ModeSelected == 1)	2489	if (ni.Speed != 0 && ni.ModeSelected == 1)
2490	{	2490	{
2491	_RowIdx++;	2491	_RowIdx++;
2492	_Content = "SPD " + ni.Speed.ToString() + " Km/h";	2492	_Content = "SPD " + ni.Speed.ToString() + " Km/h";
2493	AddLabeltoGrid(_RowIdx, 1, _Content);	2493	AddLabeltoGrid(_RowIdx, 1, _Content);
2494	}	2494	}
2495	}	2495	}
2496		2496
2497	}	2497	}
2498	_RowIdx++;	2498	_RowIdx++;
2499	}	2499	}
2500		2500
2501	}	2501	}
2502		2502
2503	}	2503	}
2504		2504
2505		2505
2506	//2017/03/07 tach rieng CreateNode start	2506	//2017/03/07 tach rieng CreateNode start
2507	private void execDeleteNode(Point FreeNode)	2507	private void execDeleteNode(Point FreeNode)
2508	{	2508	{
2509		2509
2510	double radiusNode = RADIUS_NODE;	2510	double radiusNode = RADIUS_NODE;
2511		2511
2512	EllipseGeometry ellipseGeometry;	2512	EllipseGeometry ellipseGeometry;
2513	Point node;	2513	Point node;
2514	bool deleteFlag = false;	2514	bool deleteFlag = false;
2515		2515
2516	if (gGrpBlueNode.Children.Count > 0)	2516	if (gGrpBlueNode.Children.Count > 0)
2517	{	2517	{
2518	for (int i = 0; i < gGrpBlueNode.Children.Count; i++)	2518	for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
2519	{	2519	{
2520	ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];	2520	ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
2521	node = ellipseGeometry.Center;	2521	node = ellipseGeometry.Center;
2522	if (FreeNode.X == node.X)	2522	if (FreeNode.X == node.X)
2523	{	2523	{
2524	if (CheckIsNode(FreeNode, node, radiusNode))	2524	if (CheckIsNode(FreeNode, node, radiusNode))
2525	{	2525	{
2526	deleteFlag = true;	2526	deleteFlag = true;
2527	}	2527	}
2528	}	2528	}
2529	else	2529	else
2530	{	2530	{
2531	if (CheckIsNode(FreeNode, node, radiusNode))	2531	if (CheckIsNode(FreeNode, node, radiusNode))
2532	{	2532	{
2533	deleteFlag = true;	2533	deleteFlag = true;
2534	}	2534	}
2535	}	2535	}
2536	if (deleteFlag)	2536	if (deleteFlag)
2537	{	2537	{
2538	MessageBoxResult result = MessageBox.Show("Do You Delete This Node?", "Delete Node", MessageBoxButton.OKCancel);	2538	MessageBoxResult result = MessageBox.Show("Do You Delete This Node?", "Delete Node", MessageBoxButton.OKCancel);
2539	if (result == MessageBoxResult.OK)	2539	if (result == MessageBoxResult.OK)
2540	{	2540	{
2541	DeleteNode(i);	2541	DeleteNode(i);
2542	SetScheduleRoute();	2542	SetScheduleRoute();
2543		2543
2544	return;	2544	return;
2545	}	2545	}
2546	else	2546	else
2547	{	2547	{
2548	return;	2548	return;
2549	}	2549	}
2550	}	2550	}
2551	}	2551	}
2552	}	2552	}
2553	}	2553	}
2554		2554
2555		2555
2556	private void execEditNode(Point FreeNode)	2556	private void execEditNode(Point FreeNode)
2557	{	2557	{
2558	EllipseGeometry ellipseGeometry;	2558	EllipseGeometry ellipseGeometry;
2559	Point node;	2559	Point node;
2560	for (int i = 0; i < gGrpBlueNode.Children.Count; i++)	2560	for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
2561	{	2561	{
2562	ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];	2562	ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
2563	node = ellipseGeometry.Center;	2563	node = ellipseGeometry.Center;
2564	bool isEditNode = CheckIsNode(FreeNode, node, RADIUS_NODE);	2564	bool isEditNode = CheckIsNode(FreeNode, node, RADIUS_NODE);
2565		2565
2566	if (isEditNode)	2566	if (isEditNode)
2567	{	2567	{
2568	NewEditNode(node);	2568	NewEditNode(node);
2569	NewDspRouteInfo();	2569	NewDspRouteInfo();
2570	return;	2570	return;
2571	}	2571	}
2572	}	2572	}
2573	}	2573	}
2574		2574
2575		2575
2576	private void execCreateNode(Point FreeNode)	2576	private void execCreateNode(Point FreeNode)
2577	{	2577	{
2578	bool createNodeFlag = false;	2578	bool createNodeFlag = false;
2579	string NameNode = "";	2579	string NameNode = "";
2580	//check new node in exist line	2580	//check new node in exist line
2581	if (gGrpNewLine.Children.Count > 0)	2581	if (gGrpNewLine.Children.Count > 0)
2582	{	2582	{
2583	for (int i = 0; i < gGrpNewLine.Children.Count; i++)	2583	for (int i = 0; i < gGrpNewLine.Children.Count; i++)
2584	{	2584	{
2585	LineGeometry lineGeometry = (LineGeometry)gGrpNewLine.Children[i];	2585	LineGeometry lineGeometry = (LineGeometry)gGrpNewLine.Children[i];
2586	Point p1 = lineGeometry.StartPoint;	2586	Point p1 = lineGeometry.StartPoint;
2587	Point p2 = lineGeometry.EndPoint;	2587	Point p2 = lineGeometry.EndPoint;
2588		2588
2589	bool pInL = PointInLine(FreeNode, p1, p2, UCNODE_SETLEFT);	2589	bool pInL = PointInLine(FreeNode, p1, p2, UCNODE_SETLEFT);
2590		2590
2591	if (pInL)	2591	if (pInL)
2592	{	2592	{
2593	// show form create node	2593	// show form create node
2594		2594
2595	AddNodeView edtNodeWindow = new AddNodeView();	2595	AddNodeView edtNodeWindow = new AddNodeView();
2596	edtNodeWindow.ShowDialog();	2596	edtNodeWindow.ShowDialog();
2597	createNodeFlag = edtNodeWindow.CreateNodeFlag;	2597	createNodeFlag = edtNodeWindow.CreateNodeFlag;
2598	NameNode = edtNodeWindow.NameNode;	2598	NameNode = edtNodeWindow.NameNode;
2599		2599
2600	//MessageBoxResult result = MessageBox.Show("Do You Want To Add This Node?", "Add Node", MessageBoxButton.OKCancel);	2600	//MessageBoxResult result = MessageBox.Show("Do You Want To Add This Node?", "Add Node", MessageBoxButton.OKCancel);
2601	if (createNodeFlag)	2601	if (createNodeFlag)
2602	{	2602	{
2603	Point tmpPoint = ConvertNodeinLine(FreeNode, p1, p2);	2603	Point tmpPoint = ConvertNodeinLine(FreeNode, p1, p2);
2604	FreeNode = tmpPoint;	2604	FreeNode = tmpPoint;
2605		2605
2606	CreateMapNode(FreeNode, i + 1, ColorNode_Insert, NameNode);	2606	CreateMapNode(FreeNode, i + 1, ColorNode_Insert, NameNode);
2607	gGrpBlueNode.Children.Insert(i + 1, new EllipseGeometry(FreeNode, RADIUS_NODE, RADIUS_NODE));	2607	gGrpBlueNode.Children.Insert(i + 1, new EllipseGeometry(FreeNode, RADIUS_NODE, RADIUS_NODE));
2608	//set location infor to table info	2608	//set location infor to table info
2609	SetLoc_NodeInfoList(FreeNode, i + 1);	2609	SetLoc_NodeInfoList(FreeNode, i + 1);
2610		2610
2611	SetScheduleRoute();	2611	SetScheduleRoute();
2612		2612
2613	ListIndexNodeInsert ListIndex = new ListIndexNodeInsert();	2613	ListIndexNodeInsert ListIndex = new ListIndexNodeInsert();
2614	ListIndex.X = FreeNode.X;	2614	ListIndex.X = FreeNode.X;
2615	ListIndex.Y = FreeNode.Y;	2615	ListIndex.Y = FreeNode.Y;
2616	IndexNodeInsert_List.Add(ListIndex);	2616	IndexNodeInsert_List.Add(ListIndex);
2617		2617
2618	ListNameNode ListNamenodde = new ListNameNode();	2618	ListNameNode ListNamenodde = new ListNameNode();
2619	ListNamenodde.X = FreeNode.X;	2619	ListNamenodde.X = FreeNode.X;
2620	ListNamenodde.Y = FreeNode.Y;	2620	ListNamenodde.Y = FreeNode.Y;
2621	ListNamenodde.nameNode = NameNode;	2621	ListNamenodde.nameNode = NameNode;
2622	NameNode_List.Add(ListNamenodde);	2622	NameNode_List.Add(ListNamenodde);
2623		2623
2624	//rename Point textName	2624	//rename Point textName
2625	for (int j = 0; j < ucNode_Lst.Count; j++)	2625	for (int j = 0; j < ucNode_Lst.Count; j++)
2626	{	2626	{
2627	ucNode_Lst[j].txtNode = (j + 1).ToString();	2627	ucNode_Lst[j].txtNode = (j + 1).ToString();
2628	this.Children.Remove(ucNode_Lst[j]);	2628	this.Children.Remove(ucNode_Lst[j]);
2629	this.Children.Add(ucNode_Lst[j]);	2629	this.Children.Add(ucNode_Lst[j]);
2630	}	2630	}
2631		2631
2632	ReDrawAllNode();	2632	ReDrawAllNode();
2633		2633
2634	stt++;	2634	stt++;
2635	NewInitNodeInfo_List();	2635	NewInitNodeInfo_List();
2636	NewDspRouteInfo();	2636	NewDspRouteInfo();
2637	return;	2637	return;
2638	}	2638	}
2639	else	2639	else
2640	{	2640	{
2641	return;	2641	return;
2642	}	2642	}
2643	}	2643	}
2644	}	2644	}
2645	}	2645	}
2646		2646
2647	if (readMapFan == true)	2647	if (readMapFan == true)
2648	{	2648	{
2649	CreateMapNode(FreeNode, gGrpBlueNode.Children.Count, ColorNode_Add, NameNode);	2649	CreateMapNode(FreeNode, gGrpBlueNode.Children.Count, ColorNode_Add, NameNode);
2650		2650
2651	ListNameNode ListNamenodde = new ListNameNode();	2651	ListNameNode ListNamenodde = new ListNameNode();
2652	ListNamenodde.X = FreeNode.X;	2652	ListNamenodde.X = FreeNode.X;
2653	ListNamenodde.Y = FreeNode.Y;	2653	ListNamenodde.Y = FreeNode.Y;
2654	ListNamenodde.nameNode = NameNode;	2654	ListNamenodde.nameNode = NameNode;
2655	NameNode_List.Add(ListNamenodde);	2655	NameNode_List.Add(ListNamenodde);
2656		2656
2657	gGrpBlueNode.Children.Insert(gGrpBlueNode.Children.Count, new EllipseGeometry(FreeNode, RADIUS_NODE, RADIUS_NODE));	2657	gGrpBlueNode.Children.Insert(gGrpBlueNode.Children.Count, new EllipseGeometry(FreeNode, RADIUS_NODE, RADIUS_NODE));
2658	//set location infor to table info	2658	//set location infor to table info
2659	SetLoc_NodeInfoList(FreeNode, gGrpBlueNode.Children.Count - 1);	2659	SetLoc_NodeInfoList(FreeNode, gGrpBlueNode.Children.Count - 1);
2660		2660
2661	SetScheduleRoute();	2661	SetScheduleRoute();
2662		2662
2663	//draw line	2663	//draw line
2664	if (stt > 1)	2664	if (stt > 1)
2665	{	2665	{
2666	//delete all line	2666	//delete all line
2667	gGrpNewLine.Children.Clear();	2667	gGrpNewLine.Children.Clear();
2668	this.Children.Remove(pNewLine);	2668	this.Children.Remove(pNewLine);
2669	//redraw line	2669	//redraw line
2670	for (int j = 0; j < gGrpBlueNode.Children.Count - 1; j++)	2670	for (int j = 0; j < gGrpBlueNode.Children.Count - 1; j++)
2671	{	2671	{
2672	EllipseGeometry ellip = (EllipseGeometry)gGrpBlueNode.Children[j];	2672	EllipseGeometry ellip = (EllipseGeometry)gGrpBlueNode.Children[j];
2673	Point node1 = ellip.Center;	2673	Point node1 = ellip.Center;
2674	ellip = (EllipseGeometry)gGrpBlueNode.Children[j + 1];	2674	ellip = (EllipseGeometry)gGrpBlueNode.Children[j + 1];
2675	Point node2 = ellip.Center;	2675	Point node2 = ellip.Center;
2676	DrawLine(node1, node2, gGrpNewLine);	2676	DrawLine(node1, node2, gGrpNewLine);
2677	}	2677	}
2678		2678
2679	this.Children.Add(pNewLine);	2679	this.Children.Add(pNewLine);
2680		2680
2681	//rename Point textName	2681	//rename Point textName
2682	for (int j = 0; j < ucNode_Lst.Count; j++)	2682	for (int j = 0; j < ucNode_Lst.Count; j++)
2683	{	2683	{
2684	ucNode_Lst[j].txtNode = (j + 1).ToString();	2684	ucNode_Lst[j].txtNode = (j + 1).ToString();
2685	this.Children.Remove(ucNode_Lst[j]);	2685	this.Children.Remove(ucNode_Lst[j]);
2686	this.Children.Add(ucNode_Lst[j]);	2686	this.Children.Add(ucNode_Lst[j]);
2687	}	2687	}
2688	}	2688	}
2689		2689
2690	stt++;	2690	stt++;
2691	NewInitNodeInfo_List();	2691	NewInitNodeInfo_List();
2692	NewDspRouteInfo();	2692	NewDspRouteInfo();
2693	}	2693	}
2694	else	2694	else
2695	{	2695	{
2696		2696
2697	AddNodeView createNodeWindow = new AddNodeView();	2697	AddNodeView createNodeWindow = new AddNodeView();
2698	createNodeWindow.ShowDialog();	2698	createNodeWindow.ShowDialog();
2699	createNodeFlag = createNodeWindow.CreateNodeFlag;	2699	createNodeFlag = createNodeWindow.CreateNodeFlag;
2700	NameNode = createNodeWindow.NameNode;	2700	NameNode = createNodeWindow.NameNode;
2701	if (createNodeFlag)	2701	if (createNodeFlag)
2702	{	2702	{
2703	CreateMapNode(FreeNode, gGrpBlueNode.Children.Count, ColorNode_Add, NameNode);	2703	CreateMapNode(FreeNode, gGrpBlueNode.Children.Count, ColorNode_Add, NameNode);
2704		2704
2705	ListNameNode ListNamenodde = new ListNameNode();	2705	ListNameNode ListNamenodde = new ListNameNode();
2706	ListNamenodde.X = FreeNode.X;	2706	ListNamenodde.X = FreeNode.X;
2707	ListNamenodde.Y = FreeNode.Y;	2707	ListNamenodde.Y = FreeNode.Y;
2708	ListNamenodde.nameNode = NameNode;	2708	ListNamenodde.nameNode = NameNode;
2709	NameNode_List.Add(ListNamenodde);	2709	NameNode_List.Add(ListNamenodde);
2710		2710
2711	gGrpBlueNode.Children.Insert(gGrpBlueNode.Children.Count, new EllipseGeometry(FreeNode, RADIUS_NODE, RADIUS_NODE));	2711	gGrpBlueNode.Children.Insert(gGrpBlueNode.Children.Count, new EllipseGeometry(FreeNode, RADIUS_NODE, RADIUS_NODE));
2712	//set location infor to table info	2712	//set location infor to table info
2713	SetLoc_NodeInfoList(FreeNode, gGrpBlueNode.Children.Count - 1);	2713	SetLoc_NodeInfoList(FreeNode, gGrpBlueNode.Children.Count - 1);
2714		2714
2715	SetScheduleRoute();	2715	SetScheduleRoute();
2716		2716
2717	//draw line	2717	//draw line
2718	if (stt > 1)	2718	if (stt > 1)
2719	{	2719	{
2720	//delete all line	2720	//delete all line
2721	gGrpNewLine.Children.Clear();	2721	gGrpNewLine.Children.Clear();
2722	this.Children.Remove(pNewLine);	2722	this.Children.Remove(pNewLine);
2723	//redraw line	2723	//redraw line
2724	for (int j = 0; j < gGrpBlueNode.Children.Count - 1; j++)	2724	for (int j = 0; j < gGrpBlueNode.Children.Count - 1; j++)
2725	{	2725	{
2726	EllipseGeometry ellip = (EllipseGeometry)gGrpBlueNode.Children[j];	2726	EllipseGeometry ellip = (EllipseGeometry)gGrpBlueNode.Children[j];
2727	Point node1 = ellip.Center;	2727	Point node1 = ellip.Center;
2728	ellip = (EllipseGeometry)gGrpBlueNode.Children[j + 1];	2728	ellip = (EllipseGeometry)gGrpBlueNode.Children[j + 1];
2729	Point node2 = ellip.Center;	2729	Point node2 = ellip.Center;
2730	DrawLine(node1, node2, gGrpNewLine);	2730	DrawLine(node1, node2, gGrpNewLine);
2731	}	2731	}
2732		2732
2733	this.Children.Add(pNewLine);	2733	this.Children.Add(pNewLine);
2734		2734
2735	//rename Point textName	2735	//rename Point textName
2736	for (int j = 0; j < ucNode_Lst.Count; j++)	2736	for (int j = 0; j < ucNode_Lst.Count; j++)
2737	{	2737	{
2738	ucNode_Lst[j].txtNode = (j + 1).ToString();	2738	ucNode_Lst[j].txtNode = (j + 1).ToString();
2739	this.Children.Remove(ucNode_Lst[j]);	2739	this.Children.Remove(ucNode_Lst[j]);
2740	this.Children.Add(ucNode_Lst[j]);	2740	this.Children.Add(ucNode_Lst[j]);
2741	}	2741	}
2742	}	2742	}
2743		2743
2744	stt++;	2744	stt++;
2745	NewInitNodeInfo_List();	2745	NewInitNodeInfo_List();
2746	NewDspRouteInfo();	2746	NewDspRouteInfo();
2747	}	2747	}
2748	}	2748	}
2749		2749
2750		2750
2751	}	2751	}
2752		2752
2753	public void CreateMapNode(Point FreeNode, int stt, String Color, string NameNode)	2753	public void CreateMapNode(Point FreeNode, int stt, String Color, string NameNode)
2754	{	2754	{
2755	ucNode _ucNode = new ucNode();	2755	ucNode _ucNode = new ucNode();
2756	_ucNode.btnWidth = UCNODE_WIDTH;	2756	_ucNode.btnWidth = UCNODE_WIDTH;
2757	_ucNode.btnHeight = UCNODE_HEIGHT;	2757	_ucNode.btnHeight = UCNODE_HEIGHT;
2758		2758
2759	_ucNode.txtNode = (stt + 1).ToString();	2759	_ucNode.txtNode = (stt + 1).ToString();
2760	_ucNode.coordString = NameNode;	2760	_ucNode.coordString = NameNode;
2761	_ucNode.NameNode = NameNode;	2761	_ucNode.NameNode = NameNode;
2762		2762
2763	_ucNode.fillColor = Color;	2763	_ucNode.fillColor = Color;
2764	_ucNode.IsDragDelta = true;	2764	_ucNode.IsDragDelta = true;
2765	Canvas.SetLeft(_ucNode, FreeNode.X - UCNODE_SETLEFT);	2765	Canvas.SetLeft(_ucNode, FreeNode.X - UCNODE_SETLEFT);
2766	Canvas.SetTop(_ucNode, FreeNode.Y - UCNODE_SETTOP);	2766	Canvas.SetTop(_ucNode, FreeNode.Y - UCNODE_SETTOP);
2767	this.Children.Add(_ucNode);	2767	this.Children.Add(_ucNode);
2768	//ucNode_Lst.Add(_ucNode);	2768	//ucNode_Lst.Add(_ucNode);
2769	ucNode_Lst.Insert(stt, _ucNode);	2769	ucNode_Lst.Insert(stt, _ucNode);
2770		2770
2771		2771
2772		2772
2773		2773
2774		2774
2775	//AddNode(FreeNode, gGrpBlueNode);	2775	//AddNode(FreeNode, gGrpBlueNode);
2776	//gGrpBlueNode.Children.Insert(stt, new EllipseGeometry(FreeNode, RADIUS_NODE, RADIUS_NODE));	2776	//gGrpBlueNode.Children.Insert(stt, new EllipseGeometry(FreeNode, RADIUS_NODE, RADIUS_NODE));
2777		2777
2778	}	2778	}
2779		2779
2780	public void SetLoc_NodeInfoList(Point FreeNode, int stt)	2780	public void SetLoc_NodeInfoList(Point FreeNode, int stt)
2781	{	2781	{
2782	//add location for NodeInfoList	2782	//add location for NodeInfoList
2783	Node_tmp nodetmp = new Node_tmp();	2783	Node_tmp nodetmp = new Node_tmp();
2784	nodetmp.pointMap_X = ConvertPointDisplayToActual(FreeNode.X, Scale_X, PointMapStart_X);	2784	nodetmp.pointMap_X = ConvertPointDisplayToActual(FreeNode.X, Scale_X, PointMapStart_X);
2785	nodetmp.pointMap_Y = ConvertPointDisplayToActual(FreeNode.Y, Scale_Y, PointMapStart_Y);	2785	nodetmp.pointMap_Y = ConvertPointDisplayToActual(FreeNode.Y, Scale_Y, PointMapStart_Y);
2786		2786
2787	Lst_Node_tmp.Insert(stt, nodetmp);	2787	Lst_Node_tmp.Insert(stt, nodetmp);
2788		2788
2789	}	2789	}
2790		2790
2791	public void BindBlueNode2ucNode()	2791	public void BindBlueNode2ucNode()
2792	{	2792	{
2793	string NameNode = "";	2793	string NameNode = "";
2794	bool NodeIsInsert = false;	2794	bool NodeIsInsert = false;
2795	if (gGrpBlueNode.Children.Count > 0)	2795	if (gGrpBlueNode.Children.Count > 0)
2796	{	2796	{
2797	for (int i = 0; i < gGrpBlueNode.Children.Count; i++)	2797	for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
2798	{	2798	{
2799	NodeIsInsert = false;	2799	NodeIsInsert = false;
2800	EllipseGeometry ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];	2800	EllipseGeometry ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
2801	Point node = ellipseGeometry.Center;	2801	Point node = ellipseGeometry.Center;
2802		2802
2803	//Get Name Node	2803	//Get Name Node
2804	if (NameNode_List.Count > 0)	2804	if (NameNode_List.Count > 0)
2805	{	2805	{
2806	for (int k = 0; k < NameNode_List.Count; k++)	2806	for (int k = 0; k < NameNode_List.Count; k++)
2807	{	2807	{
2808	if (node.X == NameNode_List[k].X && node.Y == NameNode_List[k].Y)	2808	if (node.X == NameNode_List[k].X && node.Y == NameNode_List[k].Y)
2809	{	2809	{
2810	NameNode = NameNode_List[k].nameNode;	2810	NameNode = NameNode_List[k].nameNode;
2811	}	2811	}
2812	}	2812	}
2813	}	2813	}
2814		2814
2815	//Draw Node Insert Color is Brown	2815	//Draw Node Insert Color is Brown
2816	if (IndexNodeInsert_List.Count > 0)	2816	if (IndexNodeInsert_List.Count > 0)
2817	{	2817	{
2818	for (int j = 0; j < IndexNodeInsert_List.Count; j++)	2818	for (int j = 0; j < IndexNodeInsert_List.Count; j++)
2819	{	2819	{
2820	if (node.X == IndexNodeInsert_List[j].X && node.Y == IndexNodeInsert_List[j].Y)	2820	if (node.X == IndexNodeInsert_List[j].X && node.Y == IndexNodeInsert_List[j].Y)
2821	{	2821	{
2822	NodeIsInsert = true;	2822	NodeIsInsert = true;
2823	}	2823	}
2824	}	2824	}
2825	}	2825	}
2826	if (NodeIsInsert)	2826	if (NodeIsInsert)
2827	{	2827	{
2828	CreateMapNode(node, i, ColorNode_Insert, NameNode);	2828	CreateMapNode(node, i, ColorNode_Insert, NameNode);
2829	}	2829	}
2830	else	2830	else
2831	{	2831	{
2832	CreateMapNode(node, i, ColorNode_Add, NameNode);	2832	CreateMapNode(node, i, ColorNode_Add, NameNode);
2833	}	2833	}
2834	}	2834	}
2835	}	2835	}
2836	}	2836	}
2837		2837
2838	//2017/03/07 tach CreateNode End	2838	//2017/03/07 tach CreateNode End
2839		2839
2840		2840
2841	public Point ConvertNodeinLine(Point point, Point l1, Point l2)	2841	public Point ConvertNodeinLine(Point point, Point l1, Point l2)
2842	{	2842	{
2843	Point pointResult = new Point();	2843	Point pointResult = new Point();
2844	double X = 0;	2844	double X = 0;
2845	double Y = 0;	2845	double Y = 0;
2846		2846
2847	double distance_Line = 0;	2847	double distance_Line = 0;
2848	double distance_l1ToPoint = 0;	2848	double distance_l1ToPoint = 0;
2849		2849
2850	distance_Line = DistanceTo(l1, l2);	2850	distance_Line = DistanceTo(l1, l2);
2851	distance_l1ToPoint = DistanceTo(l1, point);	2851	distance_l1ToPoint = DistanceTo(l1, point);
2852		2852
2853		2853
2854	if (l1.X == l2.X)	2854	if (l1.X == l2.X)
2855	{	2855	{
2856	X = l1.X;	2856	X = l1.X;
2857	Y = point.Y;	2857	Y = point.Y;
2858	}	2858	}
2859	else if (l1.Y == l2.Y)	2859	else if (l1.Y == l2.Y)
2860	{	2860	{
2861	X = point.X;	2861	X = point.X;
2862	Y = l1.Y;	2862	Y = l1.Y;
2863	}	2863	}
2864	else	2864	else
2865	{	2865	{
2866	if (l1.X < l2.X)	2866	if (l1.X < l2.X)
2867	{	2867	{
2868	if (l1.Y < l2.Y)	2868	if (l1.Y < l2.Y)
2869	{	2869	{
2870	Y = l1.Y + (distance_l1ToPoint * (l2.Y - l1.Y) / distance_Line);	2870	Y = l1.Y + (distance_l1ToPoint * (l2.Y - l1.Y) / distance_Line);
2871	X = l1.X + (distance_l1ToPoint * (l2.X - l1.X) / distance_Line);	2871	X = l1.X + (distance_l1ToPoint * (l2.X - l1.X) / distance_Line);
2872	}	2872	}
2873	else	2873	else
2874	{	2874	{
2875	Y = l1.Y - (distance_l1ToPoint * (l1.Y - l2.Y) / distance_Line);	2875	Y = l1.Y - (distance_l1ToPoint * (l1.Y - l2.Y) / distance_Line);
2876	X = l1.X + (distance_l1ToPoint * (l2.X - l1.X) / distance_Line);	2876	X = l1.X + (distance_l1ToPoint * (l2.X - l1.X) / distance_Line);
2877	}	2877	}
2878	}	2878	}
2879	else	2879	else
2880	{	2880	{
2881	if (l1.Y < l2.Y)	2881	if (l1.Y < l2.Y)
2882	{	2882	{
2883	Y = l1.Y + (distance_l1ToPoint * (l2.Y - l1.Y) / distance_Line);	2883	Y = l1.Y + (distance_l1ToPoint * (l2.Y - l1.Y) / distance_Line);
2884	X = l1.X - (distance_l1ToPoint * (l1.X - l2.X) / distance_Line);	2884	X = l1.X - (distance_l1ToPoint * (l1.X - l2.X) / distance_Line);
2885	}	2885	}
2886	else	2886	else
2887	{	2887	{
2888	Y = l1.Y - (distance_l1ToPoint * (l1.Y - l2.Y) / distance_Line);	2888	Y = l1.Y - (distance_l1ToPoint * (l1.Y - l2.Y) / distance_Line);
2889	X = l1.X - (distance_l1ToPoint * (l1.X - l2.X) / distance_Line);	2889	X = l1.X - (distance_l1ToPoint * (l1.X - l2.X) / distance_Line);
2890	}	2890	}
2891	}	2891	}
2892		2892
2893		2893
2894	}	2894	}
2895		2895
2896	pointResult.X = X;	2896	pointResult.X = X;
2897	pointResult.Y = Y;	2897	pointResult.Y = Y;
2898	return pointResult;	2898	return pointResult;
2899	}	2899	}
2900		2900
2901	public static double DistanceTo(Point point1, Point point2)	2901	public static double DistanceTo(Point point1, Point point2)
2902	{	2902	{
2903	var a = (double)(point2.X - point1.X);	2903	var a = (double)(point2.X - point1.X);
2904	var b = (double)(point2.Y - point1.Y);	2904	var b = (double)(point2.Y - point1.Y);
2905		2905
2906	return Math.Sqrt(a * a + b * b);	2906	return Math.Sqrt(a * a + b * b);
2907	}	2907	}
2908		2908
2909	public bool PointInLine(Point point, Point l1, Point l2, double radius)	2909	public bool PointInLine(Point point, Point l1, Point l2, double radius)
2910	{	2910	{
2911	double distance = 0;	2911	double distance = 0;
2912	bool falg = false;	2912	bool falg = false;
2913		2913
2914	if (l1.X < l2.X)	2914	if (l1.X < l2.X)
2915	{	2915	{
2916	if (l1.Y < l2.Y)	2916	if (l1.Y < l2.Y)
2917	{	2917	{
2918	if (point.X > l1.X - radius && point.X < l2.X + radius && point.Y > l1.Y - radius && point.Y < l2.Y + radius)	2918	if (point.X > l1.X - radius && point.X < l2.X + radius && point.Y > l1.Y - radius && point.Y < l2.Y + radius)
2919	{	2919	{
2920	falg = true;	2920	falg = true;
2921	}	2921	}
2922	}	2922	}
2923	else	2923	else
2924	{	2924	{
2925	if (point.X > l1.X - radius && point.X < l2.X + radius && point.Y < l1.Y + radius && point.Y > l2.Y - radius)	2925	if (point.X > l1.X - radius && point.X < l2.X + radius && point.Y < l1.Y + radius && point.Y > l2.Y - radius)
2926	{	2926	{
2927	falg = true;	2927	falg = true;
2928	}	2928	}
2929	}	2929	}
2930	}	2930	}
2931	else	2931	else
2932	{	2932	{
2933	if (l1.Y < l2.Y)	2933	if (l1.Y < l2.Y)
2934	{	2934	{
2935	if (point.X < l1.X + radius && point.X > l2.X - radius && point.Y > l1.Y - radius && point.Y < l2.Y + radius)	2935	if (point.X < l1.X + radius && point.X > l2.X - radius && point.Y > l1.Y - radius && point.Y < l2.Y + radius)
2936	{	2936	{
2937	falg = true;	2937	falg = true;
2938	}	2938	}
2939	}	2939	}
2940	else	2940	else
2941	{	2941	{
2942	if (point.X < l1.X + radius && point.X > l2.X - radius && point.Y < l1.Y + radius && point.Y > l2.Y - radius)	2942	if (point.X < l1.X + radius && point.X > l2.X - radius && point.Y < l1.Y + radius && point.Y > l2.Y - radius)
2943	{	2943	{
2944	falg = true;	2944	falg = true;
2945	}	2945	}
2946	}	2946	}
2947	}	2947	}
2948	if (falg == false)	2948	if (falg == false)
2949	{	2949	{
2950	return false;	2950	return false;
2951	}	2951	}
2952		2952
2953	distance = DistanceFromPointToLine(point, l1, l2);	2953	distance = DistanceFromPointToLine(point, l1, l2);
2954		2954
2955	if (distance > radius)	2955	if (distance > radius)
2956	{	2956	{
2957	return false;	2957	return false;
2958	}	2958	}
2959	return true;	2959	return true;
2960	}	2960	}
2961		2961
2962	public static double DistanceFromPointToLine(Point point, Point l1, Point l2)	2962	public static double DistanceFromPointToLine(Point point, Point l1, Point l2)
2963	{	2963	{
2964		2964
2965	return Math.Abs((l2.X - l1.X) * (l1.Y - point.Y) - (l1.X - point.X) * (l2.Y - l1.Y)) /	2965	return Math.Abs((l2.X - l1.X) * (l1.Y - point.Y) - (l1.X - point.X) * (l2.Y - l1.Y)) /
2966	Math.Sqrt(Math.Pow(l2.X - l1.X, 2) + Math.Pow(l2.Y - l1.Y, 2));	2966	Math.Sqrt(Math.Pow(l2.X - l1.X, 2) + Math.Pow(l2.Y - l1.Y, 2));
2967	}	2967	}
2968		2968
2969	#endregion	2969	#endregion
2970		2970
2971	#region Schedule	2971	#region Schedule
2972		2972
2973	public void SetScheduleRoute()	2973	public void SetScheduleRoute()
2974	{	2974	{
2975		2975
2976	EllipseGeometry ellipseGeometry_1;	2976	EllipseGeometry ellipseGeometry_1;
2977	EllipseGeometry ellipseGeometry_2;	2977	EllipseGeometry ellipseGeometry_2;
2978	Point node_1;	2978	Point node_1;
2979	Point node_2;	2979	Point node_2;
2980	Point node_Schedule = new Point();	2980	Point node_Schedule = new Point();
2981	//double x_1 = 50;	2981	//double x_1 = 50;
2982	//double y_1 = 80;	2982	//double y_1 = 80;
2983	//double Totaldistance = 1220;	2983	//double Totaldistance = 1220;
2984	double x_1 = NodeSchedule_X;	2984	double x_1 = NodeSchedule_X;
2985	double y_1 = CanvasScheduleHeight / 2;	2985	double y_1 = CanvasScheduleHeight / 2;
2986	double Totaldistance = CanvasScheduleWidth - NodeSchedule_X - NodeSchedule_X;	2986	double Totaldistance = CanvasScheduleWidth - NodeSchedule_X - NodeSchedule_X;
2987		2987
2988		2988
2989	if (ucScheduleNode_Lst.Count > 0)	2989	if (ucScheduleNode_Lst.Count > 0)
2990	{	2990	{
2991	for (int i = 0; i < ucScheduleNode_Lst.Count; i++)	2991	for (int i = 0; i < ucScheduleNode_Lst.Count; i++)
2992	{	2992	{
2993	ucNode _ucScheduleNode = new ucNode();	2993	ucNode _ucScheduleNode = new ucNode();
2994	_ucScheduleNode = ucScheduleNode_Lst[i];	2994	_ucScheduleNode = ucScheduleNode_Lst[i];
2995	scheduleCanvas.Children.Remove(_ucScheduleNode);	2995	scheduleCanvas.Children.Remove(_ucScheduleNode);
2996		2996
2997	}	2997	}
2998	ucScheduleNode_Lst.Clear();	2998	ucScheduleNode_Lst.Clear();
2999	}	2999	}
3000		3000
3001	gGrpScheduleNode.Children.Clear();	3001	gGrpScheduleNode.Children.Clear();
3002	gGrpScheduleLine.Children.Clear();	3002	gGrpScheduleLine.Children.Clear();
3003		3003
3004	//Remove existed simulation	3004	//Remove existed simulation
3005	if (scheduleCanvas.simulation != null)	3005	if (scheduleCanvas.simulation != null)
3006	{	3006	{
3007	scheduleCanvas.Children.Remove(scheduleCanvas.simulation);	3007	scheduleCanvas.Children.Remove(scheduleCanvas.simulation);
3008	}	3008	}
3009		3009
3010		3010
3011	List<double> distance = new List<double>();	3011	List<double> distance = new List<double>();
3012	double addDistance;	3012	double addDistance;
3013		3013
3014	if (gGrpBlueNode.Children.Count > 0)	3014	if (gGrpBlueNode.Children.Count > 0)
3015	{	3015	{
3016	for (int i = 0; i < gGrpBlueNode.Children.Count; i++)	3016	for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
3017	{	3017	{
3018	ellipseGeometry_2 = (EllipseGeometry)gGrpBlueNode.Children[i];	3018	ellipseGeometry_2 = (EllipseGeometry)gGrpBlueNode.Children[i];
3019	node_2 = ellipseGeometry_2.Center;	3019	node_2 = ellipseGeometry_2.Center;
3020		3020
3021	if (i >= 1)	3021	if (i >= 1)
3022	{	3022	{
3023	ellipseGeometry_1 = (EllipseGeometry)gGrpBlueNode.Children[i - 1];	3023	ellipseGeometry_1 = (EllipseGeometry)gGrpBlueNode.Children[i - 1];
3024	node_1 = ellipseGeometry_1.Center;	3024	node_1 = ellipseGeometry_1.Center;
3025	if (node_1.X == node_2.X)	3025	if (node_1.X == node_2.X)
3026	{	3026	{
3027	addDistance = Math.Abs(node_1.Y - node_2.Y);	3027	addDistance = Math.Abs(node_1.Y - node_2.Y);
3028	distance.Add(addDistance);	3028	distance.Add(addDistance);
3029	}	3029	}
3030	else if (node_1.Y == node_2.Y)	3030	else if (node_1.Y == node_2.Y)
3031	{	3031	{
3032	addDistance = Math.Abs(node_1.X - node_2.X);	3032	addDistance = Math.Abs(node_1.X - node_2.X);
3033	distance.Add(addDistance);	3033	distance.Add(addDistance);
3034	}	3034	}
3035	else	3035	else
3036	{	3036	{
3037	var a = (double)(node_2.X - node_1.X);	3037	var a = (double)(node_2.X - node_1.X);
3038	var b = (double)(node_2.Y - node_1.Y);	3038	var b = (double)(node_2.Y - node_1.Y);
3039	addDistance = Math.Sqrt(a * a + b * b);	3039	addDistance = Math.Sqrt(a * a + b * b);
3040	distance.Add(addDistance);	3040	distance.Add(addDistance);
3041	}	3041	}
3042	}	3042	}
3043	}	3043	}
3044	}	3044	}
3045	if (distance.Count > 0)	3045	if (distance.Count > 0)
3046	{	3046	{
3047	double total = 0;	3047	double total = 0;
3048	double distance_i;	3048	double distance_i;
3049		3049
3050	for (int i = 0; i < distance.Count; i++)	3050	for (int i = 0; i < distance.Count; i++)
3051	{	3051	{
3052	total = total + distance[i];	3052	total = total + distance[i];
3053	}	3053	}
3054		3054
3055	for (int i = 0; i < distance.Count; i++)	3055	for (int i = 0; i < distance.Count; i++)
3056	{	3056	{
3057	distance_i = distance[i] * (Totaldistance / total);	3057	distance_i = distance[i] * (Totaldistance / total);
3058	distance[i] = distance_i;	3058	distance[i] = distance_i;
3059	}	3059	}
3060	}	3060	}
3061		3061
3062	if (gGrpBlueNode.Children.Count > 0)	3062	if (gGrpBlueNode.Children.Count > 0)
3063	{	3063	{
3064	node_Schedule.X = x_1;	3064	node_Schedule.X = x_1;
3065	node_Schedule.Y = y_1;	3065	node_Schedule.Y = y_1;
3066	AddNode(node_Schedule, gGrpScheduleNode);	3066	AddNode(node_Schedule, gGrpScheduleNode);
3067	}	3067	}
3068		3068
3069	addDistance = x_1;	3069	addDistance = x_1;
3070	for (int i = 0; i < distance.Count; i++)	3070	for (int i = 0; i < distance.Count; i++)
3071	{	3071	{
3072		3072
3073	node_Schedule.Y = y_1;	3073	node_Schedule.Y = y_1;
3074	addDistance = addDistance + distance[i];	3074	addDistance = addDistance + distance[i];
3075	node_Schedule.X = addDistance;	3075	node_Schedule.X = addDistance;
3076	AddNode(node_Schedule, gGrpScheduleNode);	3076	AddNode(node_Schedule, gGrpScheduleNode);
3077	}	3077	}
3078		3078
3079	if (gGrpScheduleNode.Children.Count > 0)	3079	if (gGrpScheduleNode.Children.Count > 0)
3080	{	3080	{
3081	for (int i = 0; i < gGrpScheduleNode.Children.Count; i++)	3081	for (int i = 0; i < gGrpScheduleNode.Children.Count; i++)
3082	{	3082	{
3083	ellipseGeometry_1 = (EllipseGeometry)gGrpScheduleNode.Children[i];	3083	ellipseGeometry_1 = (EllipseGeometry)gGrpScheduleNode.Children[i];
3084	node_1 = ellipseGeometry_1.Center;	3084	node_1 = ellipseGeometry_1.Center;
3085	if (i > 0)	3085	if (i > 0)
3086	{	3086	{
3087	ellipseGeometry_2 = (EllipseGeometry)gGrpScheduleNode.Children[i - 1];	3087	ellipseGeometry_2 = (EllipseGeometry)gGrpScheduleNode.Children[i - 1];
3088	node_2 = ellipseGeometry_2.Center;	3088	node_2 = ellipseGeometry_2.Center;
3089	DrawLine(node_1, node_2, gGrpScheduleLine);	3089	DrawLine(node_1, node_2, gGrpScheduleLine);
3090	}	3090	}
3091	CreateScheduleNode(node_1, i + 1);	3091	CreateScheduleNode(node_1, i + 1);
3092	}	3092	}
3093	}	3093	}
3094	}	3094	}
3095		3095
3096	private void CreateScheduleNode(Point point, int indexNode)	3096	private void CreateScheduleNode(Point point, int indexNode)
3097	{	3097	{
3098	ucNode _ucNode = new ucNode();	3098	ucNode _ucNode = new ucNode();
3099	_ucNode.btnWidth = UCSCHEDULENODE_WIDTH;	3099	_ucNode.btnWidth = UCSCHEDULENODE_WIDTH;
3100	_ucNode.btnHeight = UCSCHEDULENODE_HEIGHT;	3100	_ucNode.btnHeight = UCSCHEDULENODE_HEIGHT;
3101	_ucNode.txtNode = indexNode.ToString();	3101	_ucNode.txtNode = indexNode.ToString();
3102	_ucNode.IsDragDelta = false;	3102	_ucNode.IsDragDelta = false;
3103	Canvas.SetLeft(_ucNode, point.X - UCSCHEDULENODE_SETLEFT);	3103	Canvas.SetLeft(_ucNode, point.X - UCSCHEDULENODE_SETLEFT);
3104	Canvas.SetTop(_ucNode, point.Y - UCSCHEDULENODE_SETTOP);	3104	Canvas.SetTop(_ucNode, point.Y - UCSCHEDULENODE_SETTOP);
3105	scheduleCanvas.Children.Add(_ucNode);	3105	scheduleCanvas.Children.Add(_ucNode);
3106	ucScheduleNode_Lst.Add(_ucNode);	3106	ucScheduleNode_Lst.Add(_ucNode);
3107	}	3107	}
3108		3108
3109	#endregion	3109	#endregion
3110		3110
3111	#region Add Vehicle	3111	#region Add Vehicle
3112		3112
3113	public void GetIndexProject()	3113	public void GetIndexProject()
3114	{	3114	{
3115	bool flag = false;	3115	bool flag = false;
3116	if (ProjectModel.ProjectModelList.Count > 0)	3116	if (ProjectModel.ProjectModelList.Count > 0)
3117	{	3117	{
3118	for (int i = 0; i < ProjectModel.ProjectModelList.Count; i++)	3118	for (int i = 0; i < ProjectModel.ProjectModelList.Count; i++)
3119	{	3119	{
3120	if (ProjectItem == ProjectModel.ProjectModelList[i].ProjectName)	3120	if (ProjectItem == ProjectModel.ProjectModelList[i].ProjectName)
3121	{	3121	{
3122	ProjectIndex = i;	3122	ProjectIndex = i;
3123	flag = true;	3123	flag = true;
3124	}	3124	}
3125	}	3125	}
3126	if (!flag)	3126	if (!flag)
3127	{	3127	{
3128	ProjectIndex = ProjectModel.ProjectModelList.Count;	3128	ProjectIndex = ProjectModel.ProjectModelList.Count;
3129	}	3129	}
3130	}	3130	}
3131	else	3131	else
3132	{	3132	{
3133	ProjectIndex = 0;	3133	ProjectIndex = 0;
3134	}	3134	}
3135	}	3135	}
3136		3136
3137		3137
3138		3138
3139		3139
3140	public void GetIndexVehicle()	3140	public void GetIndexVehicle()
3141	{	3141	{
3142	bool flag = false;	3142	bool flag = false;
3143		3143
3144	if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Count > 0)	3144	if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Count > 0)
3145	{	3145	{
3146	for (int i = 0; i < ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Count; i++)	3146	for (int i = 0; i < ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Count; i++)
3147	{	3147	{
3148	if (VehicleItem == ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[i].VehicleName)	3148	if (VehicleItem == ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[i].VehicleName)
3149	{	3149	{
3150	VehicleIndex = i;	3150	VehicleIndex = i;
3151	flag = true;	3151	flag = true;
3152	}	3152	}
3153	}	3153	}
3154	if (!flag)	3154	if (!flag)
3155	{	3155	{
3156	VehicleIndex = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Count;	3156	VehicleIndex = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Count;
3157	}	3157	}
3158	}	3158	}
3159	else	3159	else
3160	{	3160	{
3161	VehicleIndex = 0;	3161	VehicleIndex = 0;
3162	}	3162	}
3163	}	3163	}
3164		3164
3165	public void GetdataVehicle()	3165	public void GetdataVehicle()
3166	{	3166	{
3167	string NameNode = "";	3167	string NameNode = "";
3168		3168
3169	GetIndexProject();	3169	GetIndexProject();
3170	GetIndexVehicle();	3170	GetIndexVehicle();
3171		3171
3172	if (ProjectModel.ProjectModelList.Count > 0)	3172	if (ProjectModel.ProjectModelList.Count > 0)
3173	{	3173	{
3174	for (int i = 0; i < ucNode_Lst.Count; i++)	3174	for (int i = 0; i < ucNode_Lst.Count; i++)
3175	{	3175	{
3176	this.Children.Remove(ucNode_Lst[i]);	3176	this.Children.Remove(ucNode_Lst[i]);
3177	}	3177	}
3178		3178
3179		3179
3180	gGrpNewLine.Children.Clear();	3180	gGrpNewLine.Children.Clear();
3181	this.Children.Remove(pNewLine);	3181	this.Children.Remove(pNewLine);
3182	ucNode_Lst.Clear();	3182	ucNode_Lst.Clear();
3183	Lst_Node_tmp.Clear();	3183	Lst_Node_tmp.Clear();
3184		3184
3185		3185
3186	gGrpBlueNode.Children.Clear();	3186	gGrpBlueNode.Children.Clear();
3187	gGrpScheduleNode.Children.Clear();	3187	gGrpScheduleNode.Children.Clear();
3188	IndexNodeInsert_List.Clear();	3188	IndexNodeInsert_List.Clear();
3189	NameNode_List.Clear();	3189	NameNode_List.Clear();
3190		3190
3191	if (VehicleIndex < ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Count)	3191	if (VehicleIndex < ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Count)
3192	{	3192	{
3193		3193
3194	PointMapStart_X = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapStart_X;	3194	PointMapStart_X = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapStart_X;
3195	PointMapStart_Y = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapStart_Y;	3195	PointMapStart_Y = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapStart_Y;
3196	PointMapEnd_X = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapEnd_X;	3196	PointMapEnd_X = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapEnd_X;
3197	PointMapEnd_Y = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapEnd_Y;	3197	PointMapEnd_Y = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapEnd_Y;
3198	if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Count > 0)	3198	if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Count > 0)
3199	{	3199	{
3200	for (int k = 0; k < ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Count; k++)	3200	for (int k = 0; k < ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Count; k++)
3201	{	3201	{
3202	double X = ConvertPointActualToDisplay(ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].pointMap_X, Scale_X, PointMapStart_X);	3202	double X = ConvertPointActualToDisplay(ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].pointMap_X, Scale_X, PointMapStart_X);
3203	double Y = ConvertPointActualToDisplay(ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].pointMap_Y, Scale_Y, PointMapStart_Y);	3203	double Y = ConvertPointActualToDisplay(ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].pointMap_Y, Scale_Y, PointMapStart_Y);
3204	NameNode = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].nameNode;	3204	NameNode = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].nameNode;
3205		3205
3206	Point node = new Point(X, Y);	3206	Point node = new Point(X, Y);
3207	AddNode(node, gGrpBlueNode);	3207	AddNode(node, gGrpBlueNode);
3208		3208
3209	//Get list Node Insert	3209	//Get list Node Insert
3210	if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].color == ColorNode_Insert)	3210	if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].color == ColorNode_Insert)
3211	{	3211	{
3212	ListIndexNodeInsert ListIndex = new ListIndexNodeInsert();	3212	ListIndexNodeInsert ListIndex = new ListIndexNodeInsert();
3213	ListIndex.X = X;	3213	ListIndex.X = X;
3214	ListIndex.Y = Y;	3214	ListIndex.Y = Y;
3215	IndexNodeInsert_List.Add(ListIndex);	3215	IndexNodeInsert_List.Add(ListIndex);
3216	}	3216	}
3217		3217
3218	//Get List Name Node	3218	//Get List Name Node
3219	ListNameNode ListNamenode = new ListNameNode();	3219	ListNameNode ListNamenode = new ListNameNode();
3220	ListNamenode.X = X;	3220	ListNamenode.X = X;
3221	ListNamenode.Y = Y;	3221	ListNamenode.Y = Y;
3222	ListNamenode.nameNode = NameNode;	3222	ListNamenode.nameNode = NameNode;
3223	NameNode_List.Add(ListNamenode);	3223	NameNode_List.Add(ListNamenode);
3224		3224
3225	//Bind VehicleModel's NodeInfo to List Node Info temp	3225	//Bind VehicleModel's NodeInfo to List Node Info temp
3226	Node_tmp node_tmp = new Node_tmp();	3226	Node_tmp node_tmp = new Node_tmp();
3227	node_tmp.pointMap_X = ConvertPointDisplayToActual(X, Scale_X, PointMapStart_X);	3227	node_tmp.pointMap_X = ConvertPointDisplayToActual(X, Scale_X, PointMapStart_X);
3228	node_tmp.pointMap_Y = ConvertPointDisplayToActual(Y, Scale_Y, PointMapStart_Y);	3228	node_tmp.pointMap_Y = ConvertPointDisplayToActual(Y, Scale_Y, PointMapStart_Y);
3229		3229
3230	foreach (ListNodeInfo tmp in ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo)	3230	foreach (ListNodeInfo tmp in ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].ListNodeInfo)
3231	{	3231	{
3232	node_tmp.NodeInfo_tmp.Add(tmp);	3232	node_tmp.NodeInfo_tmp.Add(tmp);
3233	}	3233	}
3234	Lst_Node_tmp.Add(node_tmp);	3234	Lst_Node_tmp.Add(node_tmp);
3235		3235
3236		3236
3237	X = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].pointSchedule_X;	3237	X = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].pointSchedule_X;
3238	Y = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].pointSchedule_Y;	3238	Y = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].pointSchedule_Y;
3239	node = new Point(X, Y);	3239	node = new Point(X, Y);
3240	AddNode(node, gGrpScheduleNode);	3240	AddNode(node, gGrpScheduleNode);
3241		3241
3242	NameNode = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].nameNode;	3242	NameNode = ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList[k].nameNode;
3243		3243
3244	}	3244	}
3245	}	3245	}
3246	}	3246	}
3247	}	3247	}
3248		3248
3249	BindBlueNode2ucNode();	3249	BindBlueNode2ucNode();
3250		3250
3251	ReDrawAllNode();	3251	ReDrawAllNode();
3252		3252
3253	SetScheduleRoute();	3253	SetScheduleRoute();
3254		3254
3255	NewDspRouteInfo();	3255	NewDspRouteInfo();
3256		3256
3257	//Clear Route Info Table	3257	//Clear Route Info Table
3258	//((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Clear();	3258	//((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Clear();
3259		3259
3260		3260
3261	}	3261	}
3262		3262
3263	public void CreateVehicleNode()	3263	public void CreateVehicleNode()
3264	{	3264	{
3265	EllipseGeometry ellipseGeometry;	3265	EllipseGeometry ellipseGeometry;
3266	Point node;	3266	Point node;
3267	ListNodeInfo ListNodeInfo = new ListNodeInfo();	3267	ListNodeInfo ListNodeInfo = new ListNodeInfo();
3268	VehicleModelList VehicleModelList = new VehicleModelList();	3268	VehicleModelList VehicleModelList = new VehicleModelList();
3269	bool NodeISInsert = false;	3269	bool NodeISInsert = false;
3270	string NameNode = "";	3270	string NameNode = "";
3271		3271
3272	if (ProjectModel.ProjectModelList.Count == 0)	3272	if (ProjectModel.ProjectModelList.Count == 0)
3273	{	3273	{
3274	ProjectModelList ProjectModelList = new ProjectModelList();	3274	ProjectModelList ProjectModelList = new ProjectModelList();
3275	ProjectModelList.ProjectName = ProjectItem;	3275	ProjectModelList.ProjectName = ProjectItem;
3276	ProjectModel.ProjectModelList.Add(ProjectModelList);	3276	ProjectModel.ProjectModelList.Add(ProjectModelList);
3277	}	3277	}
3278		3278
3279		3279
3280	if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Count > 0 && VehicleIndex < ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Count)	3280	if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Count > 0 && VehicleIndex < ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Count)
3281	{	3281	{
3282		3282
3283	ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapStart_X = PointMapStart_X;	3283	ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapStart_X = PointMapStart_X;
3284	ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapStart_Y = PointMapStart_Y;	3284	ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapStart_Y = PointMapStart_Y;
3285	ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapEnd_X = PointMapEnd_X;	3285	ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapEnd_X = PointMapEnd_X;
3286	ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapEnd_Y = PointMapEnd_Y;	3286	ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapEnd_Y = PointMapEnd_Y;
3287		3287
3288	if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Count > 0)	3288	if (ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Count > 0)
3289	{	3289	{
3290	ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Clear();	3290	ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Clear();
3291	}	3291	}
3292		3292
3293	//back up	3293	//back up
3294	if (gGrpBlueNode.Children.Count > 0)	3294	if (gGrpBlueNode.Children.Count > 0)
3295	{	3295	{
3296	for (int i = 0; i < gGrpBlueNode.Children.Count; i++)	3296	for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
3297	{	3297	{
3298	NodeISInsert = false;	3298	NodeISInsert = false;
3299	ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];	3299	ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
3300	node = ellipseGeometry.Center;	3300	node = ellipseGeometry.Center;
3301		3301
3302	PointMap pMap = new PointMap();	3302	PointMap pMap = new PointMap();
3303	pMap.pointMap_X = ConvertPointDisplayToActual(node.X, Scale_X, PointMapStart_X);	3303	pMap.pointMap_X = ConvertPointDisplayToActual(node.X, Scale_X, PointMapStart_X);
3304	pMap.pointMap_Y = ConvertPointDisplayToActual(node.Y, Scale_Y, PointMapStart_Y);	3304	pMap.pointMap_Y = ConvertPointDisplayToActual(node.Y, Scale_Y, PointMapStart_Y);
3305	pMap.speed_Map = 1;	3305	pMap.speed_Map = 1;
3306		3306
3307	//Backup List Node Insert of fork	3307	//Backup List Node Insert of fork
3308	if (IndexNodeInsert_List.Count > 0)	3308	if (IndexNodeInsert_List.Count > 0)
3309	{	3309	{
3310	for (int j = 0; j < IndexNodeInsert_List.Count; j++)	3310	for (int j = 0; j < IndexNodeInsert_List.Count; j++)
3311	{	3311	{
3312	if (node.X == IndexNodeInsert_List[j].X && node.Y == IndexNodeInsert_List[j].Y) NodeISInsert = true;	3312	if (node.X == IndexNodeInsert_List[j].X && node.Y == IndexNodeInsert_List[j].Y) NodeISInsert = true;
3313	}	3313	}
3314	}	3314	}
3315	if (NodeISInsert)	3315	if (NodeISInsert)
3316	{	3316	{
3317	pMap.color = ColorNode_Insert;	3317	pMap.color = ColorNode_Insert;
3318	}	3318	}
3319	else	3319	else
3320	{	3320	{
3321	pMap.color = ColorNode_Add;	3321	pMap.color = ColorNode_Add;
3322	}	3322	}
3323		3323
3324	//Backup Name Node for fork	3324	//Backup Name Node for fork
3325	if (NameNode_List.Count > 0)	3325	if (NameNode_List.Count > 0)
3326	{	3326	{
3327	for (int j = 0; j < NameNode_List.Count; j++)	3327	for (int j = 0; j < NameNode_List.Count; j++)
3328	{	3328	{
3329	if (node.X == NameNode_List[j].X && node.Y == NameNode_List[j].Y) NameNode = NameNode_List[j].nameNode;	3329	if (node.X == NameNode_List[j].X && node.Y == NameNode_List[j].Y) NameNode = NameNode_List[j].nameNode;
3330	}	3330	}
3331	}	3331	}
3332	pMap.nameNode = NameNode;	3332	pMap.nameNode = NameNode;
3333		3333
3334		3334
3335	ellipseGeometry = (EllipseGeometry)gGrpScheduleNode.Children[i];	3335	ellipseGeometry = (EllipseGeometry)gGrpScheduleNode.Children[i];
3336	node = ellipseGeometry.Center;	3336	node = ellipseGeometry.Center;
3337	pMap.pointSchedule_X = node.X;	3337	pMap.pointSchedule_X = node.X;
3338	pMap.pointSchedule_Y = node.Y;	3338	pMap.pointSchedule_Y = node.Y;
3339	pMap.speed_Schedule = 0.2; //Hard code	3339	pMap.speed_Schedule = 0.2; //Hard code
3340		3340
3341	//Node info	3341	//Node info
3342	foreach (ListNodeInfo temp in Lst_Node_tmp[i].NodeInfo_tmp)	3342	foreach (ListNodeInfo temp in Lst_Node_tmp[i].NodeInfo_tmp)
3343	{	3343	{
3344	pMap.ListNodeInfo.Add(temp);	3344	pMap.ListNodeInfo.Add(temp);
3345		3345
3346	//set tam	3346	//set tam
3347	pMap.speed_Map = Lst_Node_tmp[i].NodeInfo_tmp[0].Speed;	3347	pMap.speed_Map = Lst_Node_tmp[i].NodeInfo_tmp[0].Speed;
3348	}	3348	}
3349		3349
3350	ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Add(pMap);	3350	ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList[VehicleIndex].pointMapList.Add(pMap);
3351		3351
3352	}	3352	}
3353	}	3353	}
3354	}	3354	}
3355	// create new	3355	// create new
3356	else	3356	else
3357	{	3357	{
3358	VehicleModelList.VehicleName = VehicleItem;	3358	VehicleModelList.VehicleName = VehicleItem;
3359	VehicleModelList.pointMapStart_X = PointMapStart_X;	3359	VehicleModelList.pointMapStart_X = PointMapStart_X;
3360	VehicleModelList.pointMapStart_Y = PointMapStart_Y;	3360	VehicleModelList.pointMapStart_Y = PointMapStart_Y;
3361	VehicleModelList.pointMapEnd_X = PointMapEnd_X;	3361	VehicleModelList.pointMapEnd_X = PointMapEnd_X;
3362	VehicleModelList.pointMapEnd_Y = PointMapEnd_Y;	3362	VehicleModelList.pointMapEnd_Y = PointMapEnd_Y;
3363		3363
3364	if (gGrpBlueNode.Children.Count > 0)	3364	if (gGrpBlueNode.Children.Count > 0)
3365	{	3365	{
3366	for (int i = 0; i < gGrpBlueNode.Children.Count; i++)	3366	for (int i = 0; i < gGrpBlueNode.Children.Count; i++)
3367	{	3367	{
3368	NodeISInsert = false;	3368	NodeISInsert = false;
3369	ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];	3369	ellipseGeometry = (EllipseGeometry)gGrpBlueNode.Children[i];
3370	node = ellipseGeometry.Center;	3370	node = ellipseGeometry.Center;
3371		3371
3372	PointMap pMap = new PointMap();	3372	PointMap pMap = new PointMap();
3373	pMap.pointMap_X = ConvertPointDisplayToActual(node.X, Scale_X, PointMapStart_X);	3373	pMap.pointMap_X = ConvertPointDisplayToActual(node.X, Scale_X, PointMapStart_X);
3374	pMap.pointMap_Y = ConvertPointDisplayToActual(node.Y, Scale_Y, PointMapStart_Y);	3374	pMap.pointMap_Y = ConvertPointDisplayToActual(node.Y, Scale_Y, PointMapStart_Y);
3375	pMap.speed_Map = 1;	3375	pMap.speed_Map = 1;
3376		3376
3377	//Backup List Node Insert of fork	3377	//Backup List Node Insert of fork
3378	if (IndexNodeInsert_List.Count > 0)	3378	if (IndexNodeInsert_List.Count > 0)
3379	{	3379	{
3380	for (int j = 0; j < IndexNodeInsert_List.Count; j++)	3380	for (int j = 0; j < IndexNodeInsert_List.Count; j++)
3381	{	3381	{
3382	if (node.X == IndexNodeInsert_List[j].X && node.Y == IndexNodeInsert_List[j].Y) NodeISInsert = true;	3382	if (node.X == IndexNodeInsert_List[j].X && node.Y == IndexNodeInsert_List[j].Y) NodeISInsert = true;
3383	}	3383	}
3384	}	3384	}
3385	if (NodeISInsert)	3385	if (NodeISInsert)
3386	{	3386	{
3387	pMap.color = ColorNode_Insert;	3387	pMap.color = ColorNode_Insert;
3388	}	3388	}
3389	else	3389	else
3390	{	3390	{
3391	pMap.color = ColorNode_Add;	3391	pMap.color = ColorNode_Add;
3392	}	3392	}
3393		3393
3394	//Backup Name Node for fork	3394	//Backup Name Node for fork
3395	if (NameNode_List.Count > 0)	3395	if (NameNode_List.Count > 0)
3396	{	3396	{
3397	for (int j = 0; j < NameNode_List.Count; j++)	3397	for (int j = 0; j < NameNode_List.Count; j++)
3398	{	3398	{
3399	if (node.X == NameNode_List[j].X && node.Y == NameNode_List[j].Y) NameNode = NameNode_List[j].nameNode;	3399	if (node.X == NameNode_List[j].X && node.Y == NameNode_List[j].Y) NameNode = NameNode_List[j].nameNode;
3400	}	3400	}
3401	}	3401	}
3402	pMap.nameNode = NameNode;	3402	pMap.nameNode = NameNode;
3403		3403
3404	//Node info	3404	//Node info
3405	foreach (ListNodeInfo temp in Lst_Node_tmp[i].NodeInfo_tmp)	3405	foreach (ListNodeInfo temp in Lst_Node_tmp[i].NodeInfo_tmp)
3406	{	3406	{
3407	pMap.ListNodeInfo.Add(temp);	3407	pMap.ListNodeInfo.Add(temp);
3408	}	3408	}
3409		3409
3410	ellipseGeometry = (EllipseGeometry)gGrpScheduleNode.Children[i];	3410	ellipseGeometry = (EllipseGeometry)gGrpScheduleNode.Children[i];
3411	node = ellipseGeometry.Center;	3411	node = ellipseGeometry.Center;
3412	pMap.pointSchedule_X = node.X;	3412	pMap.pointSchedule_X = node.X;
3413	pMap.pointSchedule_Y = node.Y;	3413	pMap.pointSchedule_Y = node.Y;
3414	pMap.speed_Schedule = 0.2; //Hard code	3414	pMap.speed_Schedule = 0.2; //Hard code
3415		3415
3416	VehicleModelList.pointMapList.Add(pMap);	3416	VehicleModelList.pointMapList.Add(pMap);
3417	}	3417	}
3418	}	3418	}
3419	ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Add(VehicleModelList);	3419	ProjectModel.ProjectModelList[ProjectIndex].VehicleModelList.Add(VehicleModelList);
3420	}	3420	}
3421	}	3421	}
3422	#endregion	3422	#endregion
3423		3423
3424	#region Read file Mapfan	3424	#region Read file Mapfan
3425		3425
3426	public void ReadFile()	3426	public void ReadFile()
3427	{	3427	{
3428	//Point node;	3428	//Point node;
3429	bool line1 = true;	3429	bool line1 = true;
3430	string[] lines = System.IO.File.ReadAllLines(@"Mapfan\MapFan.index");	3430	string[] lines = System.IO.File.ReadAllLines(@"Mapfan\MapFan.index");
3431		3431
3432	foreach (string line in lines)	3432	foreach (string line in lines)
3433	{	3433	{
3434	// Use a tab to indent each line of the file.	3434	// Use a tab to indent each line of the file.
3435	string[] tmp = line.Split('\t');	3435	string[] tmp = line.Split('\t');
3436	if (line1)	3436	if (line1)
3437	{	3437	{
3438	PointMapStart_X = Double.Parse(tmp[1]);	3438	PointMapStart_X = Double.Parse(tmp[1]);
3439	PointMapStart_Y = Double.Parse(tmp[3]);	3439	PointMapStart_Y = Double.Parse(tmp[3]);
3440	line1 = false;	3440	line1 = false;
3441	}	3441	}
3442	else	3442	else
3443	{	3443	{
3444	PointMapEnd_X = Double.Parse(tmp[1]);	3444	PointMapEnd_X = Double.Parse(tmp[1]);
3445	PointMapEnd_Y = Double.Parse(tmp[3]);	3445	PointMapEnd_Y = Double.Parse(tmp[3]);
3446	}	3446	}
3447	//double lat = ConvertPointActualToDisplay(Double.Parse(tmp[1]),Scale_X,PointMapStart_X);	3447	//double lat = ConvertPointActualToDisplay(Double.Parse(tmp[1]),Scale_X,PointMapStart_X);
3448	//double log = ConvertPointActualToDisplay(Double.Parse(tmp[3]),Scale_Y,PointMapStart_Y);	3448	//double log = ConvertPointActualToDisplay(Double.Parse(tmp[3]),Scale_Y,PointMapStart_Y);
3449		3449
3450	//node = new Point(lat, log);	3450	//node = new Point(lat, log);
3451		3451
3452		3452
3453	//execCreateNode(node);	3453	//execCreateNode(node);
3454	////AddNode(node, gGrpBlueNode);	3454	////AddNode(node, gGrpBlueNode);
3455		3455
3456		3456
3457	}	3457	}
3458	getScaleMap();	3458	getScaleMap();
3459		3459
3460	//SetScheduleRoute();	3460	//SetScheduleRoute();
3461	ReDrawAllNode2();	3461	ReDrawAllNode2();
3462		3462
3463	readMapFan = false;	3463	readMapFan = false;
3464	////backup DB	3464	////backup DB
3465	//CreateVehicleNode();	3465	//CreateVehicleNode();
3466		3466
3467	}	3467	}
3468	public void ReDrawAllNode2()	3468	public void ReDrawAllNode2()
3469	{	3469	{
3470	LineGeometry lineGeometry = new LineGeometry();	3470	LineGeometry lineGeometry = new LineGeometry();
3471	EllipseGeometry ellip;	3471	EllipseGeometry ellip;
3472	//delete all line	3472	//delete all line
3473	gGrpScheduleLine.Children.Clear();	3473	gGrpScheduleLine.Children.Clear();
3474	scheduleCanvas.Children.Remove(pScheduleLine);	3474	scheduleCanvas.Children.Remove(pScheduleLine);
3475		3475
3476	//redraw line	3476	//redraw line
3477	for (int j = 0; j < gGrpScheduleNode.Children.Count - 1; j++)	3477	for (int j = 0; j < gGrpScheduleNode.Children.Count - 1; j++)
3478	{	3478	{
3479	ellip = (EllipseGeometry)gGrpScheduleNode.Children[j];	3479	ellip = (EllipseGeometry)gGrpScheduleNode.Children[j];
3480	Point node1 = ellip.Center;	3480	Point node1 = ellip.Center;
3481	ellip = (EllipseGeometry)gGrpScheduleNode.Children[j + 1];	3481	ellip = (EllipseGeometry)gGrpScheduleNode.Children[j + 1];
3482	Point node2 = ellip.Center;	3482	Point node2 = ellip.Center;
3483	DrawLine(node1, node2, gGrpScheduleLine);	3483	DrawLine(node1, node2, gGrpScheduleLine);
3484	}	3484	}
3485		3485
3486	scheduleCanvas.Children.Add(pScheduleLine);	3486	scheduleCanvas.Children.Add(pScheduleLine);
3487		3487
3488		3488
3489	//redraw ucNode	3489	//redraw ucNode
3490	for (int k = 0; k < ucScheduleNode_Lst.Count; k++)	3490	for (int k = 0; k < ucScheduleNode_Lst.Count; k++)
3491	{	3491	{
3492	scheduleCanvas.Children.Remove(ucScheduleNode_Lst[k]);	3492	scheduleCanvas.Children.Remove(ucScheduleNode_Lst[k]);
3493	scheduleCanvas.Children.Add(ucScheduleNode_Lst[k]);	3493	scheduleCanvas.Children.Add(ucScheduleNode_Lst[k]);
3494	}	3494	}
3495		3495
3496	////backup DB	3496	////backup DB
3497	//CreateVehicleNode();	3497	//CreateVehicleNode();
3498	}	3498	}
3499	#endregion	3499	#endregion
3500		3500
3501	#region Get data from AWS	3501	#region Get data from AWS
3502	// Get info fork	3502	// Get info fork
3503	public void GetInfoFork()	3503	public void GetInfoFork()
3504	{	3504	{
3505	var service = new Fork2PCTableService();	3505	var service = new Fork2PCTableService();
3506	/Read/	3506	/Read/
3507	IEnumerable<Fork2PC> fork2PCs = service.GetAllFork2PCs().Where(x => x.ForkID == 1);	3507	IEnumerable<Fork2PC> fork2PCs = service.GetAllFork2PCs().Where(x => x.ForkID == 1);
3508	if (fork2PCs.Count() == 0)	3508	if (fork2PCs.Count() == 0)
3509	return;	3509	return;
3510	var fork2PC = fork2PCs.ElementAt(0);	3510	var fork2PC = fork2PCs.ElementAt(0);
3511		3511
3512	//Clear Route Info Table	3512	//Clear Route Info Table
3513	((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Clear();	3513	((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Clear();
3514		3514
3515	int _RowIdx = 0;	3515	int _RowIdx = 0;
3516	AddLabeltoGrid(_RowIdx, 0, "ID");	3516	AddLabeltoGrid(_RowIdx, 0, "ID");
3517	AddLabeltoGrid(_RowIdx, 1, fork2PC.ForkID.ToString());	3517	AddLabeltoGrid(_RowIdx, 1, fork2PC.ForkID.ToString());
3518	_RowIdx++;	3518	_RowIdx++;
3519	AddLabeltoGrid(_RowIdx, 0, "LAT");	3519	AddLabeltoGrid(_RowIdx, 0, "LAT");
3520	AddLabeltoGrid(_RowIdx, 1, fork2PC.ForkPos_x.ToString());	3520	AddLabeltoGrid(_RowIdx, 1, fork2PC.ForkPos_x.ToString());
3521	_RowIdx++;	3521	_RowIdx++;
3522	AddLabeltoGrid(_RowIdx, 0, "LOC");	3522	AddLabeltoGrid(_RowIdx, 0, "LOC");
3523	AddLabeltoGrid(_RowIdx, 1, fork2PC.ForkPos_y.ToString());	3523	AddLabeltoGrid(_RowIdx, 1, fork2PC.ForkPos_y.ToString());
3524	_RowIdx++;	3524	_RowIdx++;
3525	AddLabeltoGrid(_RowIdx, 0, "SPD");	3525	AddLabeltoGrid(_RowIdx, 0, "SPD");
3526	AddLabeltoGrid(_RowIdx, 1, fork2PC.spd_veh.ToString() + "Km/h");	3526	AddLabeltoGrid(_RowIdx, 1, fork2PC.spd_veh.ToString() + "Km/h");
3527	_RowIdx++;	3527	_RowIdx++;
3528	AddLabeltoGrid(_RowIdx, 0, "GPS");	3528	AddLabeltoGrid(_RowIdx, 0, "GPS");
3529	AddLabeltoGrid(_RowIdx, 1, fork2PC.GPS_data);	3529	AddLabeltoGrid(_RowIdx, 1, fork2PC.GPS_data);
3530	}	3530	}
3531		3531
3532	/// <summary>	3532	/// <summary>
3533	/// Get infor node	3533	/// Get infor node
3534	/// </summary>	3534	/// </summary>
		3535	public void UploadData()
		3536	{
		3537	if (ucNode_Lst.Count < 1)
		3538	return;
		3539
		3540	Robofork15DemoService service = new Robofork15DemoService();
		3541	for (int i = 0; i < ucNode_Lst.Count; i++)
		3542	{
		3543	Robofork15Demo node = new Robofork15Demo();
		3544	ucNode _ucScheduleNode = new ucNode();
		3545	_ucScheduleNode = ucNode_Lst[i];
		3546	node.NodeID = i + 1;
		3547	node.ForkNo = 1;
		3548	node.NodePos_x = Math.Round(Canvas.GetLeft(_ucScheduleNode) + UCNODE_SETLEFT, 2);
		3549	node.NodePos_y = Math.Round(Canvas.GetTop(_ucScheduleNode) + UCNODE_SETTOP, 2);
		3550	service.AddRobofork15Demo(node);
		3551	}
		3552
		3553	IEnumerable<Robofork15Demo> nodes = service.GetAllRobofork15Demos().Where(x => x.ForkNo == 1).OrderBy(x => x.NodeID);
		3554
		3555	// Delete node
		3556	if (ucNode_Lst.Count() == nodes.Count())
		3557	{
		3558	GetInfoNode();
		3559	return;
		3560	}
		3561
		3562	for (int i = ucNode_Lst.Count(); i < nodes.Count(); i++)
		3563	{
		3564	Robofork15Demo node = new Robofork15Demo();
		3565	node = nodes.ElementAt(i);
		3566	service.DeleteRobofork15Demo(node);
		3567	}
		3568	}
		3569
		3570	/// <summary>
		3571	/// Get infor node
		3572	/// </summary>
3535	public void GetInfoNode()	3573	public void GetInfoNode()
3536	{	3574	{
3537	var service = new Robofork15DemoService();	3575	var service = new Robofork15DemoService();
		3576
		3577	readMapFan = true;
3538	/Read/	3578	/Read/
3539	IEnumerable<Robofork15Demo> fork2PCs = service.GetAllRobofork15Demos().Where(x => x.ForkNo == 1).OrderBy(x => x.NodeID);	3579	IEnumerable<Robofork15Demo> nodes = service.GetAllRobofork15Demos().Where(x => x.ForkNo == 1).OrderBy(x => x.NodeID);
3540		3580
3541	//Clear Route Info Table	3581	//Clear Route Info Table
3542	((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Clear();	3582	((RoboforkMenu)System.Windows.Application.Current.MainWindow).grdRouteInfo.Children.Clear();
3543		3583
3544	// Process clear canvas	3584	// Process clear canvas
3545	ClearCanvas();	3585	ClearCanvas();
3546		3586
3547	int _RowIdx = 0;	3587	//int _RowIdx = 0;
3548	foreach (var fork2PC in fork2PCs)	3588	foreach (var node in nodes)
3549	{	3589	{
3550	ucNode _ucNode = new ucNode();	3590	//execCreateNode(new Point(ConvertPointActualToDisplay(node.NodePos_x, Scale_X, PointMapStart_X)
3551	_ucNode.txtNode = fork2PC.NodeID.ToString();	3591	// , ConvertPointActualToDisplay(node.NodePos_y, Scale_X, PointMapStart_Y)));
3552	_ucNode.IsDragDelta = true;	3592
3553	_ucNode._dataNode = fork2PC;	3593	execCreateNode(new Point(node.NodePos_x, node.NodePos_y));
3554	Canvas.SetLeft(_ucNode, fork2PC.NodePos_x - UCNODE_SETLEFT);
3555	Canvas.SetTop(_ucNode, fork2PC.NodePos_y - UCNODE_SETTOP);
3556	ucNode_Lst.Add(_ucNode);
3557	this.Children.Add(_ucNode);
3558
3559	//Column 1 : node index
3560	AddLabeltoGrid(_RowIdx, 0, fork2PC.NodeID.ToString());
3561
3562	//Column 2 : Pos_X, Pos_Y, Speed
3563	AddLabeltoGrid(_RowIdx, 1, "LAT: " + fork2PC.NodePos_x.ToString());
3564	_RowIdx++;
3565	AddLabeltoGrid(_RowIdx, 1, "LOC: " + fork2PC.NodePos_y.ToString());
3566	_RowIdx++;
3567	AddLabeltoGrid(_RowIdx, 1, "SPD: " + fork2PC.NodeVehSpd.ToString() + "Km/h");
3568	_RowIdx++;
3569	}	3594	}
		3595
		3596	CreateVehicleNode();
3570	}	3597	}
3571		3598
3572	/// <summary>	3599	/// <summary>
3573	/// Clear all data on canvas	3600	/// Clear all data on canvas
3574	/// </summary>	3601	/// </summary>
3575	public void ClearCanvas()	3602	public void ClearCanvas()
3576	{	3603	{
3577	// Clear data on designer canvas	3604	// Clear data on designer canvas
3578	for (int i = 0; i < ucNode_Lst.Count; i++)	3605	for (int i = 0; i < ucNode_Lst.Count; i++)
3579	{	3606	{
3580	this.Children.Remove(ucNode_Lst[i]);	3607	this.Children.Remove(ucNode_Lst[i]);
3581	}	3608	}
3582		3609
3583	gGrpNewLine.Children.Clear();	3610	gGrpNewLine.Children.Clear();
3584	this.Children.Remove(pNewLine);	3611	this.Children.Remove(pNewLine);
3585	ucNode_Lst.Clear();	3612	ucNode_Lst.Clear();
3586	Lst_Node_tmp.Clear();	3613	Lst_Node_tmp.Clear();
3587		3614
3588	gGrpBlueNode.Children.Clear();	3615	gGrpBlueNode.Children.Clear();
3589	gGrpScheduleNode.Children.Clear();	3616	gGrpScheduleNode.Children.Clear();
3590	IndexNodeInsert_List.Clear();	3617	IndexNodeInsert_List.Clear();
3591		3618
3592	// Clear data on schedule canvas	3619	// Clear data on schedule canvas
3593	if (ucScheduleNode_Lst.Count > 0)	3620	if (ucScheduleNode_Lst.Count > 0)
3594	{	3621	{
3595	for (int i = 0; i < ucScheduleNode_Lst.Count; i++)	3622	for (int i = 0; i < ucScheduleNode_Lst.Count; i++)
3596	{	3623	{
3597	ucNode _ucScheduleNode = new ucNode();	3624	ucNode _ucScheduleNode = new ucNode();
3598	_ucScheduleNode = ucScheduleNode_Lst[i];	3625	_ucScheduleNode = ucScheduleNode_Lst[i];
3599	scheduleCanvas.Children.Remove(_ucScheduleNode);	3626	scheduleCanvas.Children.Remove(_ucScheduleNode);
3600		3627
3601	}	3628	}
3602	ucScheduleNode_Lst.Clear();	3629	ucScheduleNode_Lst.Clear();
3603	}	3630	}
3604	gGrpScheduleNode.Children.Clear();	3631	gGrpScheduleNode.Children.Clear();
3605	gGrpScheduleLine.Children.Clear();	3632	gGrpScheduleLine.Children.Clear();
3606	}	3633	}
3607	#endregion	3634	#endregion
3608		3635
3609	#region Add new Project	3636	#region Add new Project
3610	public void AddNewProjectItem()	3637	public void AddNewProjectItem()
3611	{	3638	{
3612	ProjectModelList ProjectModelList = new ProjectModelList();	3639	ProjectModelList ProjectModelList = new ProjectModelList();
3613	ProjectModelList.ProjectName = ProjectItem;	3640	ProjectModelList.ProjectName = ProjectItem;
3614		3641
3615	ProjectModel.ProjectModelList.Add(ProjectModelList);	3642	ProjectModel.ProjectModelList.Add(ProjectModelList);
3616	}	3643	}
3617		3644
3618	#endregion	3645	#endregion
3619		3646
3620	#region get scale map	3647	#region get scale map
3621		3648
3622	public void getScaleMap()	3649	public void getScaleMap()
3623	{	3650	{
3624	Scale_X = ConvertScaleMap(PointMapEnd_X - PointMapStart_X, DISTANCEMAPDISPLAY);	3651	Scale_X = ConvertScaleMap(PointMapEnd_X - PointMapStart_X, DISTANCEMAPDISPLAY);
3625	Scale_Y = ConvertScaleMap(PointMapEnd_Y - PointMapStart_Y, DISTANCEMAPDISPLAY);	3652	Scale_Y = ConvertScaleMap(PointMapEnd_Y - PointMapStart_Y, DISTANCEMAPDISPLAY);
3626	}	3653	}
3627		3654
3628	public double ConvertScaleMap(double distance, double const1000)	3655	public double ConvertScaleMap(double distance, double const1000)
3629	{	3656	{
3630	return distance / const1000;	3657	return distance / const1000;

sources/RoboforkApp/RoboforkMenuView.xaml.cs

Diff comments View file @ e658bdc

 using RoboforkApp.DataModel;
 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.Data;
 using System.Windows.Documents;
 using System.Windows.Input;
 using System.Windows.Media;
 using System.Windows.Media.Imaging;
 using System.Windows.Shapes;
 using RoboforkApp.Commons;
 namespace RoboforkApp
 {
     /// <summary>
     /// Interaction logic for RoboforkMenu.xaml
     /// </summary>
     public partial class RoboforkMenu : Window
     {
         private Common cm = new Common();
         private const double CanvasdWidth = 1000;
         private const double CanvasHeight = 1000;
         public int IndexVehicle = 15;
         public int IndexProject = 0;
         public RoboforkMenu()
         {
             InitializeComponent();
             Load_Form();
         }
         private void Load_Form()
         {
             //PassplanTree.IsEnabled = false;
             //NodeTree.IsEnabled = false;
             MyDesignerCanvas.InitDrawRoute();
             MyDesignerCanvas.scheduleCanvas = MyScheduleCanvas;
         }
         private void Window_Loaded(object sender, RoutedEventArgs e)
         {
             GetScaleCanVas();
             GetScheduleCanVas();
             MyDesignerCanvas.ReadFile();
+            NewDoBeginSetFreeNotes();
+            DesignerCanvas.isDrawingNode = true;
+            MyDesignerCanvas.GetInfoNode();
             DisplayMap_1();
         }
         public void GetScaleCanVas()
         {
             double Width = 0;
             double Height = 0;
             Width = GridCanVas.ActualWidth;
             Height = GridCanVas.ActualHeight;
             ScaleCanvas scale = new ScaleCanvas();
             scale.scaleWidthCanvas = Width / CanvasdWidth;
             scale.scaleHeightCanvas = Height / CanvasHeight;
             this.MyDesignerCanvas.DataContext = scale;
         }
         public void GetScheduleCanVas()
         {
             double Width = 0;
             double Height = 0;
             Width = MCGridShedule.ActualWidth;
             Height = MCGridShedule.ActualHeight;
             DesignerCanvas.CanvasScheduleWidth = Width;
             DesignerCanvas.CanvasScheduleHeight = Height;
         }
         private void DisplayMap_1()
         {
             ImageBrush myBrush = new ImageBrush();
             Image image = new Image();
             //myBrush.ImageSource = new BitmapImage(new Uri(@"..\..\Images\map.png", UriKind.Relative));
             image.Source = new BitmapImage(new Uri("pack://application:,,,/Images/mapindex.png"));
             myBrush.ImageSource = image.Source;
             //Grid grid = new Grid();
             MCGrid.Background = myBrush;
         }
         private void DisplayMap_2()
         {
             ImageBrush myBrush = new ImageBrush();
             Image image = new Image();
             //myBrush.ImageSource = new BitmapImage(new Uri(@"..\..\Images\map.png", UriKind.Relative));
             image.Source = new BitmapImage(new Uri("pack://application:,,,/Images/map.png"));
             myBrush.ImageSource = image.Source;
             //Grid grid = new Grid();
             MCGrid.Background = myBrush;
         }
         private void btnMenu_Selected(object sender, RoutedEventArgs e)
         {
             if (((TreeViewItem)sender) == null)
             {
                 return;
             }
             string tag = ((TreeViewItem)sender).Tag.ToString();
             switch (tag)
             {
                 //2017/03/04 NAM ADD START1
                 case "NodeTree":
                     NewDoBeginSetFreeNotes();
                     break;
                 //2017/03/04 NAM ADD END
                 case "SetupRestriction":
                     DoBeginSetupRestriction();
                     break;
                 case "SetStart":
                     DoBeginSetStart();
                     break;
                 case "SetGoal":
                     DoBeginSetGoal();
                     break;
                 case "SetupRoute":
                     DoBeginSetupRoute();
                     break;
                 case "MakeRoot":
                     DoBeginMakeRoot();
                     break;
                 case "DeleteRoute":
                     DoBeginDeleteRoute();
                     break;
                 case "SetAutoNodes":
                     DoBeginSetAutoNotes();
                     break;
                 case "SetFreeNodes":
                     DoBeginSetFreeNotes();
                     break;
                 case "ScheduleRoute":
                     DoBeginSetSchedule();
                     break;
                 case "TaskpattermTree":
                     DoBeginTask();
                     break;
                 case "InfoFork":
                     LoadInfoFork();
                     break;
                 case "InfoNode":
                     LoadInfoNode();
                     break;
                 default:
                     break;
             }
         }
         private void DoBeginSetSchedule()
         {
             MyDesignerCanvas.SetScheduleRoute();
         }
         private void NewDoBeginSetFreeNotes()
         {
             MyDesignerCanvas.Init();
             MyDesignerCanvas.Operation = DesignerCanvas.OperationState.NewDrawSetFreeNode;
             MyDesignerCanvas.scheduleCanvas = MyScheduleCanvas;
         }
         private void LoadInfoFork()
         {
             DesignerCanvas.LoadDBFlag = true;
             MyDesignerCanvas.GetInfoFork();
         }
         private void LoadInfoNode()
         {
             DesignerCanvas.LoadDBFlag = true;
             MyDesignerCanvas.GetInfoNode();
         }
         private void btnMenu_UnselectedSet(object sender, RoutedEventArgs e)
         {
             if (((TreeViewItem)sender) == null)
             {
                 return;
             }
             string tag = ((TreeViewItem)sender).Tag.ToString();
             switch (tag)
             {
                 case "InfoFork":
                     DesignerCanvas.LoadDBFlag = false;
                     break;
                 case "InfoNode":
                     DesignerCanvas.LoadDBFlag = false;
                     break;
                 default:
                     break;
             }
         }
         private void DoBeginTask()
         {
-            MyScheduleCanvas.CreateSimulation(MyDesignerCanvas.ucScheduleNode_Lst, MyDesignerCanvas.ProjectModel.ProjectModelList[MyDesignerCanvas.ProjectIndex], MyDesignerCanvas.VehicleIndex);
+            //MyScheduleCanvas.CreateSimulation(MyDesignerCanvas.ucScheduleNode_Lst, MyDesignerCanvas.ProjectModel.ProjectModelList[MyDesignerCanvas.ProjectIndex], MyDesignerCanvas.VehicleIndex);
+            MessageBoxResult result = MessageBox.Show("Do you want upload data?", "Upload data", MessageBoxButton.OKCancel);
+            if (result == MessageBoxResult.OK)
+            {
+                MyDesignerCanvas.UploadData();
+                MyDesignerCanvas.GetInfoNode();
+            }
         }
         private void DoBeginSetAutoNotes()
         {
             MyDesignerCanvas.SetAutoNodes();
         }
         private void DoBeginSetFreeNotes()
         {
             MyDesignerCanvas.Init();
             MyDesignerCanvas.Operation = DesignerCanvas.OperationState.DrawSetFreeNode;
         }
         private void DoBeginSetupRestriction()
         {
             MyDesignerCanvas.Init();
             MyDesignerCanvas.Operation = DesignerCanvas.OperationState.DrawObstract;
             MyDesignerCanvas.mouseState = DesignerCanvas.MouseState.None;
         }
         private void DoBeginSetStart()
         {
             MyDesignerCanvas.CreateStartPoint();
         }
         private void DoBeginSetGoal()
         {
             MyDesignerCanvas.CreateGoalPoint();
         }
         private void DoBeginSetupRoute()
         {
             MyDesignerCanvas.Operation = DesignerCanvas.OperationState.DrawRoute;
         }
         private void DoBeginMakeRoot()
         {
             MyDesignerCanvas.Children.Remove(MyDesignerCanvas.pRootLine);
             MyDesignerCanvas.MakeRoot();
         }
         private void DoBeginDeleteRoute()
         {
             MessageBoxResult result = MessageBox.Show("Do you want delete route?", "Delete route", MessageBoxButton.OKCancel);
             if (result == MessageBoxResult.OK)
             {
                 MyDesignerCanvas.ClearRoute();
             }
         }
         private void GetPassplanTree(object sender, RoutedEventArgs e)
         {
             MessageBoxResult result = MessageBox.Show("Selected PassplanTree", "", MessageBoxButton.OKCancel);
         }
         private void SetPassplanTree(object sender, RoutedEventArgs e)
         {
         }
         private void GetNodeTree(object sender, RoutedEventArgs e)
         {
             MessageBoxResult result = MessageBox.Show("Selected NodeTree", "", MessageBoxButton.OKCancel);
         }
         private void SetNodeTree(object sender, RoutedEventArgs e)
         {
         }
         private void GetFK15Tree(object sender, RoutedEventArgs e)
         {
             MessageBoxResult result = MessageBox.Show("Selected FK15Tree", "", MessageBoxButton.OKCancel);
         }
         private void SetFK15Tree(object sender, RoutedEventArgs e)
         {
         }
         private void GetVehicleAddTree(object sender, RoutedEventArgs e)
         {
             MessageBoxResult result = MessageBox.Show("Selected VehicleAddTree", "", MessageBoxButton.OKCancel);
         }
         #region Add new Vehicle Item
         private void btnVehicleItem_Selected(object sender, RoutedEventArgs e)
         {
             if (((TreeViewItem)sender) == null)
             {
                 return;
             }
             string _VehicleName = ((TreeViewItem)sender).Name.ToString();
             string _VehicleTag = ((TreeViewItem)sender).Tag.ToString();
             string _VehicleHeader = ((TreeViewItem)sender).Header.ToString();
             string _ProjectName = "ProjectAAA";
             //get Parent Tree item
             TreeViewItem _VehicleItem = Vehicle;
             TreeViewItem item = e.OriginalSource as TreeViewItem;
             if (item != null)
             {
                 ItemsControl parent = cm.GetSelectedTreeViewItemParent(item);
                 _VehicleItem = parent as TreeViewItem;
             }
             //get Project item
             TreeViewItem _ProjectItem = Vehicle;
             if (_VehicleItem != null)
             {
                 ItemsControl parent = cm.GetSelectedTreeViewItemParent(_VehicleItem);
                 _ProjectItem = parent as TreeViewItem;
                 _ProjectName = _ProjectItem.Name.ToString();
             }
             switch (_VehicleTag)
             {
                 case "VehicleAddTree":
                     AddNewVehicleItem(_VehicleItem);
                     break;
                 case "VehicleItem":
                     GetDataVehicle(_ProjectName, _VehicleName, _VehicleHeader);
                     break;
                 default:
                     break;
             }
         }
         private void AddNewVehicleItem(TreeViewItem treeitem)
         {
             IndexVehicle += 1;
             treeitem.Items.RemoveAt(treeitem.Items.Count - 1);
             treeitem.Items.RemoveAt(treeitem.Items.Count - 1);
             TreeViewItem item = new TreeViewItem();
             item.Header = "FK"+ IndexVehicle.ToString()+"_#1";
             item.Tag = "VehicleItem";
             item.FontSize = 13;
             item.Selected += new RoutedEventHandler(btnVehicleItem_Selected);
             //item.IsSelected = true;
             item.IsExpanded = true;
             item.Name = "FK_" + IndexVehicle.ToString();
             treeitem.Items.Add(item);
             TreeViewItem item2 = new TreeViewItem();
             item2.Header = "[+]";
             item2.Tag = "VehicleAddTree";
             item2.FontSize = 13;
             item2.Selected += new RoutedEventHandler(btnVehicleItem_Selected);
             item2.Name = "VehicleAdd";
             treeitem.Items.Add(item2);
             TreeViewItem item3 = new TreeViewItem();
             item3.Header = "--------------------";
             item3.FontSize = 13;
             item3.Name = "UnderLine";
             treeitem.Items.Add(item3);
         }
         private void GetDataVehicle(string ProjectItem, string VehicleItem, String VehicleHeader)
         {
             if (VehicleItem == "FK_15")
             {
                 DisplayMap_1();
             }
             else
             {
                 DisplayMap_2();
             }
             MyDesignerCanvas.ProjectItem = ProjectItem;
             MyDesignerCanvas.VehicleItem = VehicleItem;
             MyDesignerCanvas.GetdataVehicle();
             LabelSchedule.Content = VehicleHeader;
             WorkVehicle.Content = "Work [" + VehicleHeader + "]";
             TaskpattermTree.Header = "Task patterm [" + VehicleHeader + "]";
         }
         #endregion
         #region Project Item
         private void btnProjectItem_Selected(object sender, RoutedEventArgs e)
         {
             if (((TreeViewItem)sender) == null)
             {
                 return;
             }
             string name = ((TreeViewItem)sender).Name.ToString();
             string tag = ((TreeViewItem)sender).Tag.ToString();
             string header = ((TreeViewItem)sender).Header.ToString();
             switch (tag)
             {
                 case "ProjectAddTree":
                     AddNewProjectItem();
                     break;
                 case "ProjectItem":
                     //GetDataProject(name, header);
                     break;
                 default:
                     break;
             }
         }
         private void AddNewProjectItem()
         {
             IndexProject += 1;
             ProjectTreeView.Items.RemoveAt(ProjectTreeView.Items.Count - 1);
             //Root Project
             TreeViewItem itemProject = new TreeViewItem();
             itemProject.Header = "Project[" + IndexProject + "工場]";
             itemProject.FontSize = 13;
             itemProject.Selected += new RoutedEventHandler(btnProjectItem_Selected);
             //itemProject.Name = "Project";
             itemProject.Name = "Project" + IndexProject;
             itemProject.Tag = "ProjectItem";
             itemProject.IsExpanded = true;
             ProjectTreeView.Items.Add(itemProject);
             //Tree Map
             TreeViewItem itemMap = new TreeViewItem();
             itemMap.Header = "Map";
             itemMap.FontSize = 13;
             itemMap.Name = "Map";
             itemProject.Items.Add(itemMap);
             TreeViewItem itemRestrict = new TreeViewItem();
             itemRestrict.Header = "Setup Restriction";
             itemRestrict.FontSize = 13;
             itemRestrict.Selected += new RoutedEventHandler(btnMenu_Selected);
             itemRestrict.Name = "SetupRestriction";
             itemRestrict.Tag = "SetupRestriction";
             itemMap.Items.Add(itemRestrict);
             TreeViewItem itemNode = new TreeViewItem();
             itemNode.Header = "Node";
             itemNode.FontSize = 13;
             itemNode.Selected += new RoutedEventHandler(btnMenu_Selected);
             itemNode.Name = "NodeTree";
             itemNode.Tag = "NodeTree";
             itemMap.Items.Add(itemNode);
             TreeViewItem itemDivision = new TreeViewItem();
             itemDivision.Header = "--------------------";
             itemDivision.FontSize = 13;
             itemMap.Items.Add(itemDivision);
             //Tree Vehicle
             TreeViewItem itemVehicle = new TreeViewItem();
             itemVehicle.Header = "Vehicle";
             itemVehicle.FontSize = 13;
             itemVehicle.Name = "Vehicle" + IndexProject.ToString();
             itemProject.Items.Add(itemVehicle);
             IndexVehicle += 1;
             TreeViewItem itemVehicleBr = new TreeViewItem();
             itemVehicleBr.Header = "FK"+ IndexVehicle.ToString()+"_#1";
             itemVehicleBr.Tag = "VehicleItem";
             itemVehicleBr.FontSize = 13;
             itemVehicleBr.Selected += new RoutedEventHandler(btnVehicleItem_Selected);
             itemVehicleBr.IsExpanded = true;
             itemVehicleBr.Name = "FK_" + IndexVehicle.ToString();
             itemVehicle.Items.Add(itemVehicleBr);
             itemVehicleBr = new TreeViewItem();
             itemVehicleBr.Header = "[+]";
             itemVehicleBr.Tag = "VehicleAddTree";
             itemVehicleBr.FontSize = 13;
             itemVehicleBr.Selected += new RoutedEventHandler(btnVehicleItem_Selected);
             itemVehicleBr.Name = "VehicleAdd";
             itemVehicle.Items.Add(itemVehicleBr);
             itemVehicleBr = new TreeViewItem();
             itemVehicleBr.Header = "--------------------";
             itemVehicleBr.FontSize = 13;
             itemVehicleBr.Name = "UnderLine";
             itemVehicle.Items.Add(itemVehicleBr);
             //Tree Work
             TreeViewItem itemWork = new TreeViewItem();
             itemWork.Header = "Work";
             itemWork.FontSize = 13;
             itemProject.Items.Add(itemWork);
             TreeViewItem itemWorkChild = new TreeViewItem();
             itemWorkChild.Header = "Task patterm [FK15_#1]";
             itemWorkChild.FontSize = 13;
             itemWorkChild.Name = "TaskpattermTree";
             itemWorkChild.Tag = "TaskpattermTree";
             itemWorkChild.Selected += new RoutedEventHandler(btnMenu_Selected);
             itemWorkChild.IsExpanded = true;
             itemWork.Items.Add(itemWorkChild);
             itemWorkChild = new TreeViewItem();
             itemWorkChild.Header = "[+]";
             itemWorkChild.FontSize = 13;
             itemWorkChild.Selected += new RoutedEventHandler(btnMenu_UnselectedSet);
             itemWorkChild.Name = "WorkAddTree";
             itemWork.Items.Add(itemWorkChild);
             itemWorkChild = new TreeViewItem();
             itemWorkChild.Header = "--------------------";
             itemWorkChild.FontSize = 13;
             itemWork.Items.Add(itemWorkChild);
             //Tree Setting
             TreeViewItem itemSetting = new TreeViewItem();
             itemSetting.Header = "Setting";
             itemSetting.FontSize = 13;
             itemProject.Items.Add(itemSetting);
             TreeViewItem itemSettingChild = new TreeViewItem();
             itemSettingChild.Header = "Connect [Wi-Fi]";
             itemSettingChild.FontSize = 13;
             itemSettingChild.Name = "ConnectTree";
             itemSettingChild.Selected += new RoutedEventHandler(btnMenu_UnselectedSet);
             itemSettingChild.IsExpanded = true;
             itemSetting.Items.Add(itemSettingChild);
             itemSettingChild = new TreeViewItem();
             itemSettingChild.Header = "Parameter";
             itemSettingChild.FontSize = 13;
             itemSettingChild.Selected += new RoutedEventHandler(btnMenu_UnselectedSet);
             itemSettingChild.Name = "ParameterTree";
             itemSetting.Items.Add(itemSettingChild);
             itemSettingChild = new TreeViewItem();
             itemSettingChild.Header = "--------------------";
             itemSettingChild.FontSize = 13;
             itemSetting.Items.Add(itemSettingChild);
             //Tree Logging
             TreeViewItem itemLog = new TreeViewItem();
             itemLog.Header = "Logging";
             itemLog.Name = "LoggingTree";
             itemLog.Selected += new RoutedEventHandler(btnMenu_UnselectedSet);
             itemLog.FontSize = 13;
             itemProject.Items.Add(itemLog);
             //Tree --------------------
             //Tree Logging
             TreeViewItem itemDash = new TreeViewItem();
             itemDash.Header = "--------------------";
             itemDash.FontSize = 13;
             itemProject.Items.Add(itemDash);
             ////Root Alert
             //TreeViewItem itemAlert = new TreeViewItem();
             //itemAlert.Header = "Alert";
             //itemAlert.FontSize = 13;
             //itemAlert.Selected += new RoutedEventHandler(GetAlertTree);
             //itemAlert.Name = "AlertTree";
             //ProjectTreeView.Items.Add(itemAlert);
             ////Root Help
             //TreeViewItem itemHelp = new TreeViewItem();
             //itemHelp.Header = "Help";
             //itemHelp.FontSize = 13;
             //itemHelp.Selected += new RoutedEventHandler(GetHelpTree);
             //itemHelp.Name = "HelpTree";
             //ProjectTreeView.Items.Add(itemHelp);
             //Root New Project
             TreeViewItem itemNewProject = new TreeViewItem();
             itemNewProject.Header = "[+New Project]";
             itemNewProject.FontSize = 13;
             itemNewProject.Selected += new RoutedEventHandler(btnProjectItem_Selected);
             itemNewProject.Name = "NewProjectTree";
             itemNewProject.Tag = "ProjectAddTree";
             ProjectTreeView.Items.Add(itemNewProject);
             MyDesignerCanvas.ProjectItem = itemProject.Name;
             MyDesignerCanvas.ProjectIndex++;
             MyDesignerCanvas.AddNewProjectItem();
         }
         #endregion
     }
 }