Compare View

switch
from
...
to
 
Commits (4)

Changes

Showing 2 changed files Inline Diff

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
1 using RoboforkApp.DataModel; 1 using RoboforkApp.DataModel;
2 using System; 2 using System;
3 using System.Collections.Generic; 3 using System.Collections.Generic;
4 using System.Linq; 4 using System.Linq;
5 using System.Text; 5 using System.Text;
6 using System.Threading.Tasks; 6 using System.Threading.Tasks;
7 using System.Windows; 7 using System.Windows;
8 using System.Windows.Controls; 8 using System.Windows.Controls;
9 using System.Windows.Data; 9 using System.Windows.Data;
10 using System.Windows.Documents; 10 using System.Windows.Documents;
11 using System.Windows.Input; 11 using System.Windows.Input;
12 using System.Windows.Media; 12 using System.Windows.Media;
13 using System.Windows.Media.Imaging; 13 using System.Windows.Media.Imaging;
14 using System.Windows.Shapes; 14 using System.Windows.Shapes;
15 using RoboforkApp.Commons; 15 using RoboforkApp.Commons;
16 16
17 namespace RoboforkApp 17 namespace RoboforkApp
18 { 18 {
19 /// <summary> 19 /// <summary>
20 /// Interaction logic for RoboforkMenu.xaml 20 /// Interaction logic for RoboforkMenu.xaml
21 /// </summary> 21 /// </summary>
22 public partial class RoboforkMenu : Window 22 public partial class RoboforkMenu : Window
23 { 23 {
24 private Common cm = new Common(); 24 private Common cm = new Common();
25 private const double CanvasdWidth = 1000; 25 private const double CanvasdWidth = 1000;
26 private const double CanvasHeight = 1000; 26 private const double CanvasHeight = 1000;
27 27
28 public int IndexVehicle = 15; 28 public int IndexVehicle = 15;
29 public int IndexProject = 0; 29 public int IndexProject = 0;
30 public RoboforkMenu() 30 public RoboforkMenu()
31 { 31 {
32 InitializeComponent(); 32 InitializeComponent();
33 Load_Form(); 33 Load_Form();
34 } 34 }
35 35
36 private void Load_Form() 36 private void Load_Form()
37 { 37 {
38 //PassplanTree.IsEnabled = false; 38 //PassplanTree.IsEnabled = false;
39 //NodeTree.IsEnabled = false; 39 //NodeTree.IsEnabled = false;
40 40
41 MyDesignerCanvas.InitDrawRoute(); 41 MyDesignerCanvas.InitDrawRoute();
42 MyDesignerCanvas.scheduleCanvas = MyScheduleCanvas; 42 MyDesignerCanvas.scheduleCanvas = MyScheduleCanvas;
43 43
44 44
45 45
46 } 46 }
47 47
48 48
49 private void Window_Loaded(object sender, RoutedEventArgs e) 49 private void Window_Loaded(object sender, RoutedEventArgs e)
50 { 50 {
51 GetScaleCanVas(); 51 GetScaleCanVas();
52 GetScheduleCanVas(); 52 GetScheduleCanVas();
53 MyDesignerCanvas.ReadFile(); 53 MyDesignerCanvas.ReadFile();
54 NewDoBeginSetFreeNotes();
55 DesignerCanvas.isDrawingNode = true;
56 MyDesignerCanvas.GetInfoNode();
54 DisplayMap_1(); 57 DisplayMap_1();
55 } 58 }
56 59
57 public void GetScaleCanVas() 60 public void GetScaleCanVas()
58 { 61 {
59 double Width = 0; 62 double Width = 0;
60 double Height = 0; 63 double Height = 0;
61 64
62 Width = GridCanVas.ActualWidth; 65 Width = GridCanVas.ActualWidth;
63 Height = GridCanVas.ActualHeight; 66 Height = GridCanVas.ActualHeight;
64 67
65 ScaleCanvas scale = new ScaleCanvas(); 68 ScaleCanvas scale = new ScaleCanvas();
66 scale.scaleWidthCanvas = Width / CanvasdWidth; 69 scale.scaleWidthCanvas = Width / CanvasdWidth;
67 scale.scaleHeightCanvas = Height / CanvasHeight; 70 scale.scaleHeightCanvas = Height / CanvasHeight;
68 71
69 this.MyDesignerCanvas.DataContext = scale; 72 this.MyDesignerCanvas.DataContext = scale;
70 } 73 }
71 74
72 public void GetScheduleCanVas() 75 public void GetScheduleCanVas()
73 { 76 {
74 double Width = 0; 77 double Width = 0;
75 double Height = 0; 78 double Height = 0;
76 79
77 Width = MCGridShedule.ActualWidth; 80 Width = MCGridShedule.ActualWidth;
78 Height = MCGridShedule.ActualHeight; 81 Height = MCGridShedule.ActualHeight;
79 DesignerCanvas.CanvasScheduleWidth = Width; 82 DesignerCanvas.CanvasScheduleWidth = Width;
80 DesignerCanvas.CanvasScheduleHeight = Height; 83 DesignerCanvas.CanvasScheduleHeight = Height;
81 } 84 }
82 85
83 private void DisplayMap_1() 86 private void DisplayMap_1()
84 { 87 {
85 88
86 ImageBrush myBrush = new ImageBrush(); 89 ImageBrush myBrush = new ImageBrush();
87 Image image = new Image(); 90 Image image = new Image();
88 //myBrush.ImageSource = new BitmapImage(new Uri(@"..\..\Images\map.png", UriKind.Relative)); 91 //myBrush.ImageSource = new BitmapImage(new Uri(@"..\..\Images\map.png", UriKind.Relative));
89 image.Source = new BitmapImage(new Uri("pack://application:,,,/Images/mapindex.png")); 92 image.Source = new BitmapImage(new Uri("pack://application:,,,/Images/mapindex.png"));
90 myBrush.ImageSource = image.Source; 93 myBrush.ImageSource = image.Source;
91 //Grid grid = new Grid(); 94 //Grid grid = new Grid();
92 MCGrid.Background = myBrush; 95 MCGrid.Background = myBrush;
93 } 96 }
94 97
95 98
96 private void DisplayMap_2() 99 private void DisplayMap_2()
97 { 100 {
98 101
99 ImageBrush myBrush = new ImageBrush(); 102 ImageBrush myBrush = new ImageBrush();
100 Image image = new Image(); 103 Image image = new Image();
101 //myBrush.ImageSource = new BitmapImage(new Uri(@"..\..\Images\map.png", UriKind.Relative)); 104 //myBrush.ImageSource = new BitmapImage(new Uri(@"..\..\Images\map.png", UriKind.Relative));
102 image.Source = new BitmapImage(new Uri("pack://application:,,,/Images/map.png")); 105 image.Source = new BitmapImage(new Uri("pack://application:,,,/Images/map.png"));
103 myBrush.ImageSource = image.Source; 106 myBrush.ImageSource = image.Source;
104 //Grid grid = new Grid(); 107 //Grid grid = new Grid();
105 MCGrid.Background = myBrush; 108 MCGrid.Background = myBrush;
106 } 109 }
107 110
108 private void btnMenu_Selected(object sender, RoutedEventArgs e) 111 private void btnMenu_Selected(object sender, RoutedEventArgs e)
109 { 112 {
110 if (((TreeViewItem)sender) == null) 113 if (((TreeViewItem)sender) == null)
111 { 114 {
112 return; 115 return;
113 } 116 }
114 117
115 string tag = ((TreeViewItem)sender).Tag.ToString(); 118 string tag = ((TreeViewItem)sender).Tag.ToString();
116 switch (tag) 119 switch (tag)
117 { 120 {
118 //2017/03/04 NAM ADD START1 121 //2017/03/04 NAM ADD START1
119 case "NodeTree": 122 case "NodeTree":
120 NewDoBeginSetFreeNotes(); 123 NewDoBeginSetFreeNotes();
121 break; 124 break;
122 //2017/03/04 NAM ADD END 125 //2017/03/04 NAM ADD END
123 126
124 case "SetupRestriction": 127 case "SetupRestriction":
125 DoBeginSetupRestriction(); 128 DoBeginSetupRestriction();
126 break; 129 break;
127 130
128 case "SetStart": 131 case "SetStart":
129 DoBeginSetStart(); 132 DoBeginSetStart();
130 break; 133 break;
131 134
132 case "SetGoal": 135 case "SetGoal":
133 DoBeginSetGoal(); 136 DoBeginSetGoal();
134 break; 137 break;
135 138
136 case "SetupRoute": 139 case "SetupRoute":
137 DoBeginSetupRoute(); 140 DoBeginSetupRoute();
138 break; 141 break;
139 142
140 case "MakeRoot": 143 case "MakeRoot":
141 DoBeginMakeRoot(); 144 DoBeginMakeRoot();
142 break; 145 break;
143 146
144 case "DeleteRoute": 147 case "DeleteRoute":
145 DoBeginDeleteRoute(); 148 DoBeginDeleteRoute();
146 break; 149 break;
147 150
148 case "SetAutoNodes": 151 case "SetAutoNodes":
149 DoBeginSetAutoNotes(); 152 DoBeginSetAutoNotes();
150 break; 153 break;
151 154
152 case "SetFreeNodes": 155 case "SetFreeNodes":
153 DoBeginSetFreeNotes(); 156 DoBeginSetFreeNotes();
154 break; 157 break;
155 158
156 case "ScheduleRoute": 159 case "ScheduleRoute":
157 160
158 DoBeginSetSchedule(); 161 DoBeginSetSchedule();
159 break; 162 break;
160 case "TaskpattermTree": 163 case "TaskpattermTree":
161 DoBeginTask(); 164 DoBeginTask();
162 break; 165 break;
163 case "InfoFork": 166 case "InfoFork":
164 LoadInfoFork(); 167 LoadInfoFork();
165 break; 168 break;
166 case "InfoNode": 169 case "InfoNode":
167 LoadInfoNode(); 170 LoadInfoNode();
168 break; 171 break;
169 172
170 default: 173 default:
171 break; 174 break;
172 } 175 }
173 } 176 }
174 177
175 private void DoBeginSetSchedule() 178 private void DoBeginSetSchedule()
176 { 179 {
177 180
178 MyDesignerCanvas.SetScheduleRoute(); 181 MyDesignerCanvas.SetScheduleRoute();
179 } 182 }
180 183
181 private void NewDoBeginSetFreeNotes() 184 private void NewDoBeginSetFreeNotes()
182 { 185 {
183 MyDesignerCanvas.Init(); 186 MyDesignerCanvas.Init();
184 MyDesignerCanvas.Operation = DesignerCanvas.OperationState.NewDrawSetFreeNode; 187 MyDesignerCanvas.Operation = DesignerCanvas.OperationState.NewDrawSetFreeNode;
185 MyDesignerCanvas.scheduleCanvas = MyScheduleCanvas; 188 MyDesignerCanvas.scheduleCanvas = MyScheduleCanvas;
186 } 189 }
187 190
188 private void LoadInfoFork() 191 private void LoadInfoFork()
189 { 192 {
190 DesignerCanvas.LoadDBFlag = true; 193 DesignerCanvas.LoadDBFlag = true;
191 MyDesignerCanvas.GetInfoFork(); 194 MyDesignerCanvas.GetInfoFork();
192 } 195 }
193 196
194 private void LoadInfoNode() 197 private void LoadInfoNode()
195 { 198 {
196 DesignerCanvas.LoadDBFlag = true; 199 DesignerCanvas.LoadDBFlag = true;
197 MyDesignerCanvas.GetInfoNode(); 200 MyDesignerCanvas.GetInfoNode();
198 } 201 }
199 202
200 private void btnMenu_UnselectedSet(object sender, RoutedEventArgs e) 203 private void btnMenu_UnselectedSet(object sender, RoutedEventArgs e)
201 { 204 {
202 if (((TreeViewItem)sender) == null) 205 if (((TreeViewItem)sender) == null)
203 { 206 {
204 return; 207 return;
205 } 208 }
206 209
207 string tag = ((TreeViewItem)sender).Tag.ToString(); 210 string tag = ((TreeViewItem)sender).Tag.ToString();
208 switch (tag) 211 switch (tag)
209 { 212 {
210 case "InfoFork": 213 case "InfoFork":
211 DesignerCanvas.LoadDBFlag = false; 214 DesignerCanvas.LoadDBFlag = false;
212 break; 215 break;
213 case "InfoNode": 216 case "InfoNode":
214 DesignerCanvas.LoadDBFlag = false; 217 DesignerCanvas.LoadDBFlag = false;
215 break; 218 break;
216 default: 219 default:
217 break; 220 break;
218 } 221 }
219 } 222 }
220 223
221 private void DoBeginTask() 224 private void DoBeginTask()
222 { 225 {
223 MyScheduleCanvas.CreateSimulation(MyDesignerCanvas.ucScheduleNode_Lst, MyDesignerCanvas.ProjectModel.ProjectModelList[MyDesignerCanvas.ProjectIndex], MyDesignerCanvas.VehicleIndex); 226 //MyScheduleCanvas.CreateSimulation(MyDesignerCanvas.ucScheduleNode_Lst, MyDesignerCanvas.ProjectModel.ProjectModelList[MyDesignerCanvas.ProjectIndex], MyDesignerCanvas.VehicleIndex);
227 MessageBoxResult result = MessageBox.Show("Do you want upload data?", "Upload data", MessageBoxButton.OKCancel);
228 if (result == MessageBoxResult.OK)
229 {
230 MyDesignerCanvas.UploadData();
231 MyDesignerCanvas.GetInfoNode();
232 }
224 } 233 }
225 234
226 private void DoBeginSetAutoNotes() 235 private void DoBeginSetAutoNotes()
227 { 236 {
228 MyDesignerCanvas.SetAutoNodes(); 237 MyDesignerCanvas.SetAutoNodes();
229 } 238 }
230 239
231 private void DoBeginSetFreeNotes() 240 private void DoBeginSetFreeNotes()
232 { 241 {
233 MyDesignerCanvas.Init(); 242 MyDesignerCanvas.Init();
234 MyDesignerCanvas.Operation = DesignerCanvas.OperationState.DrawSetFreeNode; 243 MyDesignerCanvas.Operation = DesignerCanvas.OperationState.DrawSetFreeNode;
235 } 244 }
236 245
237 private void DoBeginSetupRestriction() 246 private void DoBeginSetupRestriction()
238 { 247 {
239 MyDesignerCanvas.Init(); 248 MyDesignerCanvas.Init();
240 MyDesignerCanvas.Operation = DesignerCanvas.OperationState.DrawObstract; 249 MyDesignerCanvas.Operation = DesignerCanvas.OperationState.DrawObstract;
241 MyDesignerCanvas.mouseState = DesignerCanvas.MouseState.None; 250 MyDesignerCanvas.mouseState = DesignerCanvas.MouseState.None;
242 } 251 }
243 252
244 private void DoBeginSetStart() 253 private void DoBeginSetStart()
245 { 254 {
246 MyDesignerCanvas.CreateStartPoint(); 255 MyDesignerCanvas.CreateStartPoint();
247 } 256 }
248 257
249 private void DoBeginSetGoal() 258 private void DoBeginSetGoal()
250 { 259 {
251 MyDesignerCanvas.CreateGoalPoint(); 260 MyDesignerCanvas.CreateGoalPoint();
252 } 261 }
253 262
254 private void DoBeginSetupRoute() 263 private void DoBeginSetupRoute()
255 { 264 {
256 MyDesignerCanvas.Operation = DesignerCanvas.OperationState.DrawRoute; 265 MyDesignerCanvas.Operation = DesignerCanvas.OperationState.DrawRoute;
257 } 266 }
258 267
259 private void DoBeginMakeRoot() 268 private void DoBeginMakeRoot()
260 { 269 {
261 MyDesignerCanvas.Children.Remove(MyDesignerCanvas.pRootLine); 270 MyDesignerCanvas.Children.Remove(MyDesignerCanvas.pRootLine);
262 MyDesignerCanvas.MakeRoot(); 271 MyDesignerCanvas.MakeRoot();
263 } 272 }
264 273
265 private void DoBeginDeleteRoute() 274 private void DoBeginDeleteRoute()
266 { 275 {
267 MessageBoxResult result = MessageBox.Show("Do you want delete route?", "Delete route", MessageBoxButton.OKCancel); 276 MessageBoxResult result = MessageBox.Show("Do you want delete route?", "Delete route", MessageBoxButton.OKCancel);
268 if (result == MessageBoxResult.OK) 277 if (result == MessageBoxResult.OK)
269 { 278 {
270 MyDesignerCanvas.ClearRoute(); 279 MyDesignerCanvas.ClearRoute();
271 } 280 }
272 } 281 }
273 282
274 private void GetPassplanTree(object sender, RoutedEventArgs e) 283 private void GetPassplanTree(object sender, RoutedEventArgs e)
275 { 284 {
276 MessageBoxResult result = MessageBox.Show("Selected PassplanTree", "", MessageBoxButton.OKCancel); 285 MessageBoxResult result = MessageBox.Show("Selected PassplanTree", "", MessageBoxButton.OKCancel);
277 } 286 }
278 287
279 private void SetPassplanTree(object sender, RoutedEventArgs e) 288 private void SetPassplanTree(object sender, RoutedEventArgs e)
280 { 289 {
281 290
282 } 291 }
283 292
284 private void GetNodeTree(object sender, RoutedEventArgs e) 293 private void GetNodeTree(object sender, RoutedEventArgs e)
285 { 294 {
286 MessageBoxResult result = MessageBox.Show("Selected NodeTree", "", MessageBoxButton.OKCancel); 295 MessageBoxResult result = MessageBox.Show("Selected NodeTree", "", MessageBoxButton.OKCancel);
287 } 296 }
288 297
289 private void SetNodeTree(object sender, RoutedEventArgs e) 298 private void SetNodeTree(object sender, RoutedEventArgs e)
290 { 299 {
291 300
292 } 301 }
293 302
294 private void GetFK15Tree(object sender, RoutedEventArgs e) 303 private void GetFK15Tree(object sender, RoutedEventArgs e)
295 { 304 {
296 MessageBoxResult result = MessageBox.Show("Selected FK15Tree", "", MessageBoxButton.OKCancel); 305 MessageBoxResult result = MessageBox.Show("Selected FK15Tree", "", MessageBoxButton.OKCancel);
297 } 306 }
298 307
299 private void SetFK15Tree(object sender, RoutedEventArgs e) 308 private void SetFK15Tree(object sender, RoutedEventArgs e)
300 { 309 {
301 310
302 } 311 }
303 312
304 private void GetVehicleAddTree(object sender, RoutedEventArgs e) 313 private void GetVehicleAddTree(object sender, RoutedEventArgs e)
305 { 314 {
306 MessageBoxResult result = MessageBox.Show("Selected VehicleAddTree", "", MessageBoxButton.OKCancel); 315 MessageBoxResult result = MessageBox.Show("Selected VehicleAddTree", "", MessageBoxButton.OKCancel);
307 } 316 }
308 317
309 #region Add new Vehicle Item 318 #region Add new Vehicle Item
310 319
311 private void btnVehicleItem_Selected(object sender, RoutedEventArgs e) 320 private void btnVehicleItem_Selected(object sender, RoutedEventArgs e)
312 { 321 {
313 if (((TreeViewItem)sender) == null) 322 if (((TreeViewItem)sender) == null)
314 { 323 {
315 return; 324 return;
316 } 325 }
317 string _VehicleName = ((TreeViewItem)sender).Name.ToString(); 326 string _VehicleName = ((TreeViewItem)sender).Name.ToString();
318 string _VehicleTag = ((TreeViewItem)sender).Tag.ToString(); 327 string _VehicleTag = ((TreeViewItem)sender).Tag.ToString();
319 string _VehicleHeader = ((TreeViewItem)sender).Header.ToString(); 328 string _VehicleHeader = ((TreeViewItem)sender).Header.ToString();
320 string _ProjectName = "ProjectAAA"; 329 string _ProjectName = "ProjectAAA";
321 330
322 //get Parent Tree item 331 //get Parent Tree item
323 TreeViewItem _VehicleItem = Vehicle; 332 TreeViewItem _VehicleItem = Vehicle;
324 TreeViewItem item = e.OriginalSource as TreeViewItem; 333 TreeViewItem item = e.OriginalSource as TreeViewItem;
325 if (item != null) 334 if (item != null)
326 { 335 {
327 ItemsControl parent = cm.GetSelectedTreeViewItemParent(item); 336 ItemsControl parent = cm.GetSelectedTreeViewItemParent(item);
328 _VehicleItem = parent as TreeViewItem; 337 _VehicleItem = parent as TreeViewItem;
329 } 338 }
330 339
331 //get Project item 340 //get Project item
332 TreeViewItem _ProjectItem = Vehicle; 341 TreeViewItem _ProjectItem = Vehicle;
333 if (_VehicleItem != null) 342 if (_VehicleItem != null)
334 { 343 {
335 ItemsControl parent = cm.GetSelectedTreeViewItemParent(_VehicleItem); 344 ItemsControl parent = cm.GetSelectedTreeViewItemParent(_VehicleItem);
336 _ProjectItem = parent as TreeViewItem; 345 _ProjectItem = parent as TreeViewItem;
337 _ProjectName = _ProjectItem.Name.ToString(); 346 _ProjectName = _ProjectItem.Name.ToString();
338 } 347 }
339 348
340 349
341 350
342 switch (_VehicleTag) 351 switch (_VehicleTag)
343 { 352 {
344 case "VehicleAddTree": 353 case "VehicleAddTree":
345 AddNewVehicleItem(_VehicleItem); 354 AddNewVehicleItem(_VehicleItem);
346 break; 355 break;
347 356
348 case "VehicleItem": 357 case "VehicleItem":
349 GetDataVehicle(_ProjectName, _VehicleName, _VehicleHeader); 358 GetDataVehicle(_ProjectName, _VehicleName, _VehicleHeader);
350 break; 359 break;
351 360
352 default: 361 default:
353 break; 362 break;
354 } 363 }
355 } 364 }
356 365
357 366
358 private void AddNewVehicleItem(TreeViewItem treeitem) 367 private void AddNewVehicleItem(TreeViewItem treeitem)
359 { 368 {
360 IndexVehicle += 1; 369 IndexVehicle += 1;
361 370
362 treeitem.Items.RemoveAt(treeitem.Items.Count - 1); 371 treeitem.Items.RemoveAt(treeitem.Items.Count - 1);
363 treeitem.Items.RemoveAt(treeitem.Items.Count - 1); 372 treeitem.Items.RemoveAt(treeitem.Items.Count - 1);
364 373
365 TreeViewItem item = new TreeViewItem(); 374 TreeViewItem item = new TreeViewItem();
366 item.Header = "FK"+ IndexVehicle.ToString()+"_#1"; 375 item.Header = "FK"+ IndexVehicle.ToString()+"_#1";
367 item.Tag = "VehicleItem"; 376 item.Tag = "VehicleItem";
368 item.FontSize = 13; 377 item.FontSize = 13;
369 item.Selected += new RoutedEventHandler(btnVehicleItem_Selected); 378 item.Selected += new RoutedEventHandler(btnVehicleItem_Selected);
370 //item.IsSelected = true; 379 //item.IsSelected = true;
371 item.IsExpanded = true; 380 item.IsExpanded = true;
372 item.Name = "FK_" + IndexVehicle.ToString(); 381 item.Name = "FK_" + IndexVehicle.ToString();
373 treeitem.Items.Add(item); 382 treeitem.Items.Add(item);
374 383
375 TreeViewItem item2 = new TreeViewItem(); 384 TreeViewItem item2 = new TreeViewItem();
376 item2.Header = "[+]"; 385 item2.Header = "[+]";
377 item2.Tag = "VehicleAddTree"; 386 item2.Tag = "VehicleAddTree";
378 item2.FontSize = 13; 387 item2.FontSize = 13;
379 item2.Selected += new RoutedEventHandler(btnVehicleItem_Selected); 388 item2.Selected += new RoutedEventHandler(btnVehicleItem_Selected);
380 item2.Name = "VehicleAdd"; 389 item2.Name = "VehicleAdd";
381 treeitem.Items.Add(item2); 390 treeitem.Items.Add(item2);
382 391
383 TreeViewItem item3 = new TreeViewItem(); 392 TreeViewItem item3 = new TreeViewItem();
384 item3.Header = "--------------------"; 393 item3.Header = "--------------------";
385 item3.FontSize = 13; 394 item3.FontSize = 13;
386 item3.Name = "UnderLine"; 395 item3.Name = "UnderLine";
387 treeitem.Items.Add(item3); 396 treeitem.Items.Add(item3);
388 397
389 } 398 }
390 399
391 400
392 private void GetDataVehicle(string ProjectItem, string VehicleItem, String VehicleHeader) 401 private void GetDataVehicle(string ProjectItem, string VehicleItem, String VehicleHeader)
393 { 402 {
394 if (VehicleItem == "FK_15") 403 if (VehicleItem == "FK_15")
395 { 404 {
396 DisplayMap_1(); 405 DisplayMap_1();
397 } 406 }
398 else 407 else
399 { 408 {
400 DisplayMap_2(); 409 DisplayMap_2();
401 } 410 }
402 411
403 MyDesignerCanvas.ProjectItem = ProjectItem; 412 MyDesignerCanvas.ProjectItem = ProjectItem;
404 MyDesignerCanvas.VehicleItem = VehicleItem; 413 MyDesignerCanvas.VehicleItem = VehicleItem;
405 MyDesignerCanvas.GetdataVehicle(); 414 MyDesignerCanvas.GetdataVehicle();
406 LabelSchedule.Content = VehicleHeader; 415 LabelSchedule.Content = VehicleHeader;
407 WorkVehicle.Content = "Work [" + VehicleHeader + "]"; 416 WorkVehicle.Content = "Work [" + VehicleHeader + "]";
408 TaskpattermTree.Header = "Task patterm [" + VehicleHeader + "]"; 417 TaskpattermTree.Header = "Task patterm [" + VehicleHeader + "]";
409 } 418 }
410 419
411 #endregion 420 #endregion
412 421
413 #region Project Item 422 #region Project Item
414 423
415 private void btnProjectItem_Selected(object sender, RoutedEventArgs e) 424 private void btnProjectItem_Selected(object sender, RoutedEventArgs e)
416 { 425 {
417 if (((TreeViewItem)sender) == null) 426 if (((TreeViewItem)sender) == null)
418 { 427 {
419 return; 428 return;
420 } 429 }
421 string name = ((TreeViewItem)sender).Name.ToString(); 430 string name = ((TreeViewItem)sender).Name.ToString();
422 string tag = ((TreeViewItem)sender).Tag.ToString(); 431 string tag = ((TreeViewItem)sender).Tag.ToString();
423 string header = ((TreeViewItem)sender).Header.ToString(); 432 string header = ((TreeViewItem)sender).Header.ToString();
424 switch (tag) 433 switch (tag)
425 { 434 {
426 case "ProjectAddTree": 435 case "ProjectAddTree":
427 AddNewProjectItem(); 436 AddNewProjectItem();
428 break; 437 break;
429 438
430 case "ProjectItem": 439 case "ProjectItem":
431 //GetDataProject(name, header); 440 //GetDataProject(name, header);
432 break; 441 break;
433 442
434 default: 443 default:
435 break; 444 break;
436 } 445 }
437 } 446 }
438 447
439 448
440 private void AddNewProjectItem() 449 private void AddNewProjectItem()
441 { 450 {
442 IndexProject += 1; 451 IndexProject += 1;
443 452
444 ProjectTreeView.Items.RemoveAt(ProjectTreeView.Items.Count - 1); 453 ProjectTreeView.Items.RemoveAt(ProjectTreeView.Items.Count - 1);
445 454
446 //Root Project 455 //Root Project
447 TreeViewItem itemProject = new TreeViewItem(); 456 TreeViewItem itemProject = new TreeViewItem();
448 itemProject.Header = "Project[" + IndexProject + "工場]"; 457 itemProject.Header = "Project[" + IndexProject + "工場]";
449 itemProject.FontSize = 13; 458 itemProject.FontSize = 13;
450 itemProject.Selected += new RoutedEventHandler(btnProjectItem_Selected); 459 itemProject.Selected += new RoutedEventHandler(btnProjectItem_Selected);
451 //itemProject.Name = "Project"; 460 //itemProject.Name = "Project";
452 itemProject.Name = "Project" + IndexProject; 461 itemProject.Name = "Project" + IndexProject;
453 itemProject.Tag = "ProjectItem"; 462 itemProject.Tag = "ProjectItem";
454 itemProject.IsExpanded = true; 463 itemProject.IsExpanded = true;
455 ProjectTreeView.Items.Add(itemProject); 464 ProjectTreeView.Items.Add(itemProject);
456 465
457 //Tree Map 466 //Tree Map
458 TreeViewItem itemMap = new TreeViewItem(); 467 TreeViewItem itemMap = new TreeViewItem();
459 itemMap.Header = "Map"; 468 itemMap.Header = "Map";
460 itemMap.FontSize = 13; 469 itemMap.FontSize = 13;
461 itemMap.Name = "Map"; 470 itemMap.Name = "Map";
462 itemProject.Items.Add(itemMap); 471 itemProject.Items.Add(itemMap);
463 472
464 473
465 TreeViewItem itemRestrict = new TreeViewItem(); 474 TreeViewItem itemRestrict = new TreeViewItem();
466 itemRestrict.Header = "Setup Restriction"; 475 itemRestrict.Header = "Setup Restriction";
467 itemRestrict.FontSize = 13; 476 itemRestrict.FontSize = 13;
468 itemRestrict.Selected += new RoutedEventHandler(btnMenu_Selected); 477 itemRestrict.Selected += new RoutedEventHandler(btnMenu_Selected);
469 itemRestrict.Name = "SetupRestriction"; 478 itemRestrict.Name = "SetupRestriction";
470 itemRestrict.Tag = "SetupRestriction"; 479 itemRestrict.Tag = "SetupRestriction";
471 itemMap.Items.Add(itemRestrict); 480 itemMap.Items.Add(itemRestrict);
472 481
473 482
474 TreeViewItem itemNode = new TreeViewItem(); 483 TreeViewItem itemNode = new TreeViewItem();
475 itemNode.Header = "Node"; 484 itemNode.Header = "Node";
476 itemNode.FontSize = 13; 485 itemNode.FontSize = 13;
477 itemNode.Selected += new RoutedEventHandler(btnMenu_Selected); 486 itemNode.Selected += new RoutedEventHandler(btnMenu_Selected);
478 itemNode.Name = "NodeTree"; 487 itemNode.Name = "NodeTree";
479 itemNode.Tag = "NodeTree"; 488 itemNode.Tag = "NodeTree";
480 itemMap.Items.Add(itemNode); 489 itemMap.Items.Add(itemNode);
481 490
482 TreeViewItem itemDivision = new TreeViewItem(); 491 TreeViewItem itemDivision = new TreeViewItem();
483 itemDivision.Header = "--------------------"; 492 itemDivision.Header = "--------------------";
484 itemDivision.FontSize = 13; 493 itemDivision.FontSize = 13;
485 itemMap.Items.Add(itemDivision); 494 itemMap.Items.Add(itemDivision);
486 495
487 //Tree Vehicle 496 //Tree Vehicle
488 TreeViewItem itemVehicle = new TreeViewItem(); 497 TreeViewItem itemVehicle = new TreeViewItem();
489 itemVehicle.Header = "Vehicle"; 498 itemVehicle.Header = "Vehicle";
490 itemVehicle.FontSize = 13; 499 itemVehicle.FontSize = 13;
491 itemVehicle.Name = "Vehicle" + IndexProject.ToString(); 500 itemVehicle.Name = "Vehicle" + IndexProject.ToString();
492 itemProject.Items.Add(itemVehicle); 501 itemProject.Items.Add(itemVehicle);
493 502
494 IndexVehicle += 1; 503 IndexVehicle += 1;
495 504
496 TreeViewItem itemVehicleBr = new TreeViewItem(); 505 TreeViewItem itemVehicleBr = new TreeViewItem();
497 itemVehicleBr.Header = "FK"+ IndexVehicle.ToString()+"_#1"; 506 itemVehicleBr.Header = "FK"+ IndexVehicle.ToString()+"_#1";
498 itemVehicleBr.Tag = "VehicleItem"; 507 itemVehicleBr.Tag = "VehicleItem";
499 itemVehicleBr.FontSize = 13; 508 itemVehicleBr.FontSize = 13;
500 itemVehicleBr.Selected += new RoutedEventHandler(btnVehicleItem_Selected); 509 itemVehicleBr.Selected += new RoutedEventHandler(btnVehicleItem_Selected);
501 itemVehicleBr.IsExpanded = true; 510 itemVehicleBr.IsExpanded = true;
502 itemVehicleBr.Name = "FK_" + IndexVehicle.ToString(); 511 itemVehicleBr.Name = "FK_" + IndexVehicle.ToString();
503 itemVehicle.Items.Add(itemVehicleBr); 512 itemVehicle.Items.Add(itemVehicleBr);
504 513
505 itemVehicleBr = new TreeViewItem(); 514 itemVehicleBr = new TreeViewItem();
506 itemVehicleBr.Header = "[+]"; 515 itemVehicleBr.Header = "[+]";
507 itemVehicleBr.Tag = "VehicleAddTree"; 516 itemVehicleBr.Tag = "VehicleAddTree";
508 itemVehicleBr.FontSize = 13; 517 itemVehicleBr.FontSize = 13;
509 itemVehicleBr.Selected += new RoutedEventHandler(btnVehicleItem_Selected); 518 itemVehicleBr.Selected += new RoutedEventHandler(btnVehicleItem_Selected);
510 itemVehicleBr.Name = "VehicleAdd"; 519 itemVehicleBr.Name = "VehicleAdd";
511 itemVehicle.Items.Add(itemVehicleBr); 520 itemVehicle.Items.Add(itemVehicleBr);
512 521
513 itemVehicleBr = new TreeViewItem(); 522 itemVehicleBr = new TreeViewItem();
514 itemVehicleBr.Header = "--------------------"; 523 itemVehicleBr.Header = "--------------------";
515 itemVehicleBr.FontSize = 13; 524 itemVehicleBr.FontSize = 13;
516 itemVehicleBr.Name = "UnderLine"; 525 itemVehicleBr.Name = "UnderLine";
517 itemVehicle.Items.Add(itemVehicleBr); 526 itemVehicle.Items.Add(itemVehicleBr);
518 527
519 528
520 //Tree Work 529 //Tree Work
521 TreeViewItem itemWork = new TreeViewItem(); 530 TreeViewItem itemWork = new TreeViewItem();
522 itemWork.Header = "Work"; 531 itemWork.Header = "Work";
523 itemWork.FontSize = 13; 532 itemWork.FontSize = 13;
524 itemProject.Items.Add(itemWork); 533 itemProject.Items.Add(itemWork);
525 534
526 TreeViewItem itemWorkChild = new TreeViewItem(); 535 TreeViewItem itemWorkChild = new TreeViewItem();
527 itemWorkChild.Header = "Task patterm [FK15_#1]"; 536 itemWorkChild.Header = "Task patterm [FK15_#1]";
528 itemWorkChild.FontSize = 13; 537 itemWorkChild.FontSize = 13;
529 itemWorkChild.Name = "TaskpattermTree"; 538 itemWorkChild.Name = "TaskpattermTree";
530 itemWorkChild.Tag = "TaskpattermTree"; 539 itemWorkChild.Tag = "TaskpattermTree";
531 itemWorkChild.Selected += new RoutedEventHandler(btnMenu_Selected); 540 itemWorkChild.Selected += new RoutedEventHandler(btnMenu_Selected);
532 itemWorkChild.IsExpanded = true; 541 itemWorkChild.IsExpanded = true;
533 itemWork.Items.Add(itemWorkChild); 542 itemWork.Items.Add(itemWorkChild);
534 543
535 itemWorkChild = new TreeViewItem(); 544 itemWorkChild = new TreeViewItem();
536 itemWorkChild.Header = "[+]"; 545 itemWorkChild.Header = "[+]";
537 itemWorkChild.FontSize = 13; 546 itemWorkChild.FontSize = 13;
538 itemWorkChild.Selected += new RoutedEventHandler(btnMenu_UnselectedSet); 547 itemWorkChild.Selected += new RoutedEventHandler(btnMenu_UnselectedSet);
539 itemWorkChild.Name = "WorkAddTree"; 548 itemWorkChild.Name = "WorkAddTree";
540 itemWork.Items.Add(itemWorkChild); 549 itemWork.Items.Add(itemWorkChild);
541 550
542 itemWorkChild = new TreeViewItem(); 551 itemWorkChild = new TreeViewItem();
543 itemWorkChild.Header = "--------------------"; 552 itemWorkChild.Header = "--------------------";
544 itemWorkChild.FontSize = 13; 553 itemWorkChild.FontSize = 13;
545 itemWork.Items.Add(itemWorkChild); 554 itemWork.Items.Add(itemWorkChild);
546 555
547 556
548 //Tree Setting 557 //Tree Setting
549 TreeViewItem itemSetting = new TreeViewItem(); 558 TreeViewItem itemSetting = new TreeViewItem();
550 itemSetting.Header = "Setting"; 559 itemSetting.Header = "Setting";
551 itemSetting.FontSize = 13; 560 itemSetting.FontSize = 13;
552 itemProject.Items.Add(itemSetting); 561 itemProject.Items.Add(itemSetting);
553 562
554 TreeViewItem itemSettingChild = new TreeViewItem(); 563 TreeViewItem itemSettingChild = new TreeViewItem();
555 itemSettingChild.Header = "Connect [Wi-Fi]"; 564 itemSettingChild.Header = "Connect [Wi-Fi]";
556 itemSettingChild.FontSize = 13; 565 itemSettingChild.FontSize = 13;
557 itemSettingChild.Name = "ConnectTree"; 566 itemSettingChild.Name = "ConnectTree";
558 itemSettingChild.Selected += new RoutedEventHandler(btnMenu_UnselectedSet); 567 itemSettingChild.Selected += new RoutedEventHandler(btnMenu_UnselectedSet);
559 itemSettingChild.IsExpanded = true; 568 itemSettingChild.IsExpanded = true;
560 itemSetting.Items.Add(itemSettingChild); 569 itemSetting.Items.Add(itemSettingChild);
561 570
562 itemSettingChild = new TreeViewItem(); 571 itemSettingChild = new TreeViewItem();
563 itemSettingChild.Header = "Parameter"; 572 itemSettingChild.Header = "Parameter";
564 itemSettingChild.FontSize = 13; 573 itemSettingChild.FontSize = 13;
565 itemSettingChild.Selected += new RoutedEventHandler(btnMenu_UnselectedSet); 574 itemSettingChild.Selected += new RoutedEventHandler(btnMenu_UnselectedSet);
566 itemSettingChild.Name = "ParameterTree"; 575 itemSettingChild.Name = "ParameterTree";
567 itemSetting.Items.Add(itemSettingChild); 576 itemSetting.Items.Add(itemSettingChild);
568 577
569 itemSettingChild = new TreeViewItem(); 578 itemSettingChild = new TreeViewItem();
570 itemSettingChild.Header = "--------------------"; 579 itemSettingChild.Header = "--------------------";
571 itemSettingChild.FontSize = 13; 580 itemSettingChild.FontSize = 13;
572 itemSetting.Items.Add(itemSettingChild); 581 itemSetting.Items.Add(itemSettingChild);
573 582
574 583
575 //Tree Logging 584 //Tree Logging
576 TreeViewItem itemLog = new TreeViewItem(); 585 TreeViewItem itemLog = new TreeViewItem();
577 itemLog.Header = "Logging"; 586 itemLog.Header = "Logging";
578 itemLog.Name = "LoggingTree"; 587 itemLog.Name = "LoggingTree";
579 itemLog.Selected += new RoutedEventHandler(btnMenu_UnselectedSet); 588 itemLog.Selected += new RoutedEventHandler(btnMenu_UnselectedSet);
580 itemLog.FontSize = 13; 589 itemLog.FontSize = 13;
581 itemProject.Items.Add(itemLog); 590 itemProject.Items.Add(itemLog);
582 591
583 //Tree -------------------- 592 //Tree --------------------
584 //Tree Logging 593 //Tree Logging
585 TreeViewItem itemDash = new TreeViewItem(); 594 TreeViewItem itemDash = new TreeViewItem();
586 itemDash.Header = "--------------------"; 595 itemDash.Header = "--------------------";
587 itemDash.FontSize = 13; 596 itemDash.FontSize = 13;
588 itemProject.Items.Add(itemDash); 597 itemProject.Items.Add(itemDash);
589 598
590 599
591 ////Root Alert 600 ////Root Alert
592 //TreeViewItem itemAlert = new TreeViewItem(); 601 //TreeViewItem itemAlert = new TreeViewItem();
593 //itemAlert.Header = "Alert"; 602 //itemAlert.Header = "Alert";
594 //itemAlert.FontSize = 13; 603 //itemAlert.FontSize = 13;
595 //itemAlert.Selected += new RoutedEventHandler(GetAlertTree); 604 //itemAlert.Selected += new RoutedEventHandler(GetAlertTree);
596 //itemAlert.Name = "AlertTree"; 605 //itemAlert.Name = "AlertTree";
597 //ProjectTreeView.Items.Add(itemAlert); 606 //ProjectTreeView.Items.Add(itemAlert);
598 607
599 ////Root Help 608 ////Root Help
600 //TreeViewItem itemHelp = new TreeViewItem(); 609 //TreeViewItem itemHelp = new TreeViewItem();
601 //itemHelp.Header = "Help"; 610 //itemHelp.Header = "Help";
602 //itemHelp.FontSize = 13; 611 //itemHelp.FontSize = 13;
603 //itemHelp.Selected += new RoutedEventHandler(GetHelpTree); 612 //itemHelp.Selected += new RoutedEventHandler(GetHelpTree);
604 //itemHelp.Name = "HelpTree"; 613 //itemHelp.Name = "HelpTree";
605 //ProjectTreeView.Items.Add(itemHelp); 614 //ProjectTreeView.Items.Add(itemHelp);
606 615
607 616
608 //Root New Project 617 //Root New Project
609 TreeViewItem itemNewProject = new TreeViewItem(); 618 TreeViewItem itemNewProject = new TreeViewItem();
610 itemNewProject.Header = "[+New Project]"; 619 itemNewProject.Header = "[+New Project]";
611 itemNewProject.FontSize = 13; 620 itemNewProject.FontSize = 13;
612 itemNewProject.Selected += new RoutedEventHandler(btnProjectItem_Selected); 621 itemNewProject.Selected += new RoutedEventHandler(btnProjectItem_Selected);
613 itemNewProject.Name = "NewProjectTree"; 622 itemNewProject.Name = "NewProjectTree";
614 itemNewProject.Tag = "ProjectAddTree"; 623 itemNewProject.Tag = "ProjectAddTree";
615 ProjectTreeView.Items.Add(itemNewProject); 624 ProjectTreeView.Items.Add(itemNewProject);
616 625
617 MyDesignerCanvas.ProjectItem = itemProject.Name; 626 MyDesignerCanvas.ProjectItem = itemProject.Name;
618 MyDesignerCanvas.ProjectIndex++; 627 MyDesignerCanvas.ProjectIndex++;
619 MyDesignerCanvas.AddNewProjectItem(); 628 MyDesignerCanvas.AddNewProjectItem();
620 629
621 630
622 } 631 }
623 #endregion 632 #endregion
624 633
625 634
626 } 635 }
627 } 636 }
628 637