PageRenderTime 65ms CodeModel.GetById 35ms RepoModel.GetById 0ms app.codeStats 1ms

/WickedFlame.VecDraw.Core/Shapes/PolygonShape.cs

#
C# | 823 lines | 594 code | 97 blank | 132 comment | 124 complexity | 14b0637068a826e11033a1f0b54eedd3 MD5 | raw file
Possible License(s): CC-BY-SA-3.0
  1. using System;
  2. using System.Windows;
  3. using System.Windows.Media;
  4. using WickedFlame.Core.State;
  5. namespace WickedFlame.Core.Shapes
  6. {
  7. public class PolygonShape : VectorShape, IPolygonShape, IStateCapturable, ICopyable
  8. {
  9. public PolygonShape()
  10. : this(new Point(0, 0))
  11. {
  12. }
  13. public PolygonShape(Point start)
  14. {
  15. _definingGeometry = new PathGeometry();
  16. var col = new PathSegmentCollection();
  17. var fig = new PathFigure(start, col, false);
  18. _definingGeometry.Figures.Add(fig);
  19. }
  20. public PolygonShape(string source)
  21. {
  22. _definingGeometry = (PathGeometry)Geometry.Parse(source);
  23. }
  24. PathGeometry _definingGeometry;
  25. public PathGeometry DefiningGeometry
  26. {
  27. get
  28. {
  29. if (_definingGeometry == null)
  30. {
  31. _definingGeometry = new PathGeometry();
  32. var col = new PathSegmentCollection();
  33. var fig = new PathFigure(StartPoint, col, false);
  34. _definingGeometry.Figures.Add(fig);
  35. }
  36. return _definingGeometry;
  37. }
  38. }
  39. public string GeometryString
  40. {
  41. get
  42. {
  43. return DefiningGeometry.ToString();
  44. }
  45. }
  46. public override Rect Bounds
  47. {
  48. get
  49. {
  50. return DefiningGeometry.Bounds;
  51. }
  52. }
  53. //protected override void OnPropertyChanged(DependencyPropertyChangedEventArgs e)
  54. //{
  55. // base.OnPropertyChanged(e);
  56. // DependencyProperty prop = e.Property;
  57. // if (prop == )
  58. // {
  59. // //JoinEndSegments
  60. //}
  61. public override void Draw(DrawingContext drawingContext)
  62. {
  63. drawingContext.DrawGeometry(
  64. Fill,
  65. //new Pen(Stroke, StrokeThickness),
  66. Pen,
  67. DefiningGeometry);
  68. }
  69. public override void DrawTracker(DrawingContext drawingContext, double scale)
  70. {
  71. var p = new Pen(Brushes.Blue, 0.5 / scale);
  72. var p2 = new Pen(Brushes.Blue, 1 / scale);
  73. Point lastSegmentPoint = _definingGeometry.Figures[0].StartPoint;
  74. foreach (PathSegment segment in _definingGeometry.Figures[0].Segments)
  75. {
  76. if (segment is LineSegment)
  77. {
  78. drawingContext.DrawLine(p, lastSegmentPoint, ((LineSegment)segment).Point);
  79. drawingContext.DrawEllipse(Brushes.LightBlue, p2, ((LineSegment)segment).Point, 2.5 / scale, 2.5 / scale);
  80. lastSegmentPoint = ((LineSegment)segment).Point;
  81. }
  82. else if (segment is QuadraticBezierSegment)
  83. {
  84. drawingContext.DrawLine(p, lastSegmentPoint, ((QuadraticBezierSegment)segment).Point1);
  85. drawingContext.DrawLine(p, ((QuadraticBezierSegment)segment).Point1, ((QuadraticBezierSegment)segment).Point2);
  86. drawingContext.DrawEllipse(Brushes.LightBlue, p2, ((QuadraticBezierSegment)segment).Point1, 2.5 / scale, 2.5 / scale);
  87. drawingContext.DrawEllipse(Brushes.LightBlue, p2, ((QuadraticBezierSegment)segment).Point2, 2.5 / scale, 2.5 / scale);
  88. lastSegmentPoint = ((QuadraticBezierSegment)segment).Point2;
  89. }
  90. else if (segment is BezierSegment)
  91. {
  92. //Pen p = new Pen(Brushes.Blue, 0.5);
  93. drawingContext.DrawLine(p, lastSegmentPoint, ((BezierSegment)segment).Point1);
  94. drawingContext.DrawLine(p, ((BezierSegment)segment).Point2, ((BezierSegment)segment).Point3);
  95. //p = new Pen(Brushes.Blue, 1);
  96. drawingContext.DrawEllipse(Brushes.LightBlue, p2, ((BezierSegment)segment).Point1, 2.5 / scale, 2.5 / scale);
  97. drawingContext.DrawEllipse(Brushes.LightBlue, p2, ((BezierSegment)segment).Point2, 2.5 / scale, 2.5 / scale);
  98. drawingContext.DrawEllipse(Brushes.LightBlue, p2, ((BezierSegment)segment).Point3, 2.5 / scale, 2.5 / scale);
  99. lastSegmentPoint = ((BezierSegment)segment).Point3;
  100. }
  101. else
  102. throw new NotImplementedException("Segmenttype is not jet implemented");
  103. }
  104. if (!(SelectedTracker == 1))
  105. drawingContext.DrawEllipse(Brushes.LightBlue, p2, _definingGeometry.Figures[0].StartPoint, 2.5 / scale, 2.5 / scale);
  106. else
  107. drawingContext.DrawEllipse(Brushes.White, new Pen(Brushes.Black, 2 / scale), _definingGeometry.Figures[0].StartPoint, 2.5 / scale, 2.5 / scale);
  108. if(SelectedTracker==TrackerCount)
  109. drawingContext.DrawEllipse(Brushes.White, new Pen(Brushes.Black, 2 / scale), GetTracker(SelectedTracker), 2.5 / scale, 2.5 / scale);
  110. }
  111. public Point StartPoint
  112. {
  113. get
  114. {
  115. return DefiningGeometry.Figures[0].StartPoint;
  116. }
  117. set
  118. {
  119. DefiningGeometry.Figures[0].StartPoint = value;
  120. }
  121. }
  122. public Point EndPoint
  123. {
  124. get
  125. {
  126. var point = new Point(0, 0);
  127. if (DefiningGeometry.Figures[0].Segments.Count > 0)
  128. {
  129. PathSegment segment = DefiningGeometry.Figures[0].Segments[DefiningGeometry.Figures[0].Segments.Count - 1];
  130. if (segment is LineSegment)
  131. {
  132. point = ((LineSegment)segment).Point;
  133. }
  134. else if (segment is QuadraticBezierSegment)
  135. {
  136. point = ((QuadraticBezierSegment)segment).Point2;
  137. }
  138. else if (segment is BezierSegment)
  139. {
  140. point = ((BezierSegment)segment).Point3;
  141. }
  142. else
  143. throw new NotImplementedException("Segmenttype is not jet implemented");
  144. }
  145. return point;
  146. }
  147. }
  148. private PathSegmentCollection Segments
  149. {
  150. get
  151. {
  152. return DefiningGeometry.Figures[0].Segments;
  153. }
  154. set
  155. {
  156. DefiningGeometry.Figures[0].Segments = value;
  157. }
  158. }
  159. //public override VectorShape Clone()
  160. //{
  161. // var shape = new VECPolygon(this.StartPoint);
  162. // //shape.StartPoint = this.StartPoint;
  163. // foreach (PathSegment segment in Segments)
  164. // {
  165. // if (segment is LineSegment)
  166. // {
  167. // shape.Segments.Add(new LineSegment(((LineSegment)segment).Point, true));
  168. // }
  169. // else if (segment is QuadraticBezierSegment)
  170. // {
  171. // shape.Segments.Add(new QuadraticBezierSegment(((QuadraticBezierSegment)segment).Point1,
  172. // ((QuadraticBezierSegment)segment).Point2, true));
  173. // }
  174. // else
  175. // throw new NotImplementedException("Segmenttype is not jet implemented");
  176. // }
  177. // CopyShapeProperies(shape);
  178. // return shape;
  179. //}
  180. public override bool IntersectsWith(Rect rectangle)
  181. {
  182. var rectgeo = new RectangleGeometry(rectangle, 0, 0);
  183. var det = DefiningGeometry.StrokeContainsWithDetail(Pen/*new Pen(this.Stroke, this.StrokeThickness)*/, rectgeo);
  184. if (det == IntersectionDetail.FullyContains || det == IntersectionDetail.FullyInside || det == IntersectionDetail.Intersects)
  185. return true;
  186. return false;
  187. }
  188. public void AddLineSegment(Point point)
  189. {
  190. DefiningGeometry.Figures[0].Segments.Add(new LineSegment(point, true));
  191. this.Invalidate();
  192. }
  193. public void AddSegment(PathSegment segment, Point startPoint)
  194. {
  195. //TODO!
  196. //check wich side is selected and add the segment to that side!
  197. if (SelectedTracker == 1)
  198. {
  199. if (segment is LineSegment)
  200. {
  201. (segment as LineSegment).Point = StartPoint;
  202. //DefiningGeometry.Figures[0].Segments.Insert(0, segment);
  203. //StartPoint = startPoint;
  204. }
  205. else if (segment is QuadraticBezierSegment)
  206. {
  207. (segment as QuadraticBezierSegment).Point2 = StartPoint;
  208. //StartPoint = startPoint;
  209. }
  210. else if (segment is BezierSegment)
  211. {
  212. (segment as BezierSegment).Point3 = StartPoint;
  213. //StartPoint = startPoint;
  214. }
  215. else
  216. throw new ShapeException("Segmenttype is not jet implemented");
  217. DefiningGeometry.Figures[0].Segments.Insert(0, segment);
  218. StartPoint = startPoint;
  219. }
  220. else
  221. DefiningGeometry.Figures[0].Segments.Add(segment);
  222. this.Invalidate();
  223. }
  224. public bool JoinEndSegments
  225. {
  226. get
  227. {
  228. return DefiningGeometry.Figures[0].IsClosed;
  229. }
  230. set
  231. {
  232. if (value)
  233. Segments.RemoveAt(Segments.Count - 1);
  234. else
  235. Segments.Add(new LineSegment(new Point(DefiningGeometry.Figures[0].StartPoint.X, DefiningGeometry.Figures[0].StartPoint.Y), false));
  236. DefiningGeometry.Figures[0].IsClosed = value;
  237. }
  238. }
  239. public override int TrackerCount
  240. {
  241. get
  242. {
  243. int cnt = 0;
  244. foreach (PathSegment segment in DefiningGeometry.Figures[0].Segments)
  245. {
  246. if (segment is LineSegment)
  247. cnt++;
  248. else if (segment is QuadraticBezierSegment)
  249. cnt += 2;
  250. else if (segment is BezierSegment)
  251. cnt += 3;
  252. else
  253. throw new NotImplementedException("Segmenttype is not jet implemented");
  254. }
  255. return cnt + 1; // add start point
  256. }
  257. }
  258. public override void SelectTracker(int tracker)
  259. {
  260. if (tracker == 1 || tracker == TrackerCount)
  261. base.SelectTracker(tracker);
  262. }
  263. public int MaxHandle
  264. {
  265. get
  266. {
  267. return DefiningGeometry.Figures[0].Segments.Count + 1;
  268. }
  269. }
  270. /// <summary>
  271. /// Get handle point by 1-based number
  272. /// </summary>
  273. /// <param name="trackerNo"></param>
  274. /// <returns></returns>
  275. public override Point GetTracker(int trackerNo)
  276. {
  277. if (trackerNo == 1)
  278. return DefiningGeometry.Figures[0].StartPoint;
  279. int ti = 0;
  280. int i = 0;
  281. int tcnt = 0;
  282. while (ti < trackerNo-2)
  283. {
  284. if (DefiningGeometry.Figures[0].Segments[i] is LineSegment)
  285. {
  286. i++;
  287. }
  288. else if (DefiningGeometry.Figures[0].Segments[i] is QuadraticBezierSegment)
  289. {
  290. tcnt++;
  291. if (tcnt == 2)
  292. {
  293. i++;
  294. tcnt = 0;
  295. }
  296. }
  297. else if (DefiningGeometry.Figures[0].Segments[i] is BezierSegment)
  298. {
  299. tcnt++;
  300. if (tcnt == 3)
  301. {
  302. i++;
  303. tcnt = 0;
  304. }
  305. }
  306. else
  307. throw new NotImplementedException("Segmenttype is not jet implemented");
  308. ti++;
  309. }
  310. if (DefiningGeometry.Figures[0].Segments[i] is LineSegment)
  311. {
  312. return ((LineSegment)DefiningGeometry.Figures[0].Segments[i]).Point;
  313. }
  314. else if (DefiningGeometry.Figures[0].Segments[i] is QuadraticBezierSegment)
  315. {
  316. if (tcnt == 1)
  317. {
  318. return ((QuadraticBezierSegment)DefiningGeometry.Figures[0].Segments[i]).Point2;
  319. }
  320. else
  321. {
  322. return ((QuadraticBezierSegment)DefiningGeometry.Figures[0].Segments[i]).Point1;
  323. }
  324. }
  325. else if (DefiningGeometry.Figures[0].Segments[i] is BezierSegment)
  326. {
  327. if (tcnt == 2)
  328. {
  329. return ((BezierSegment)DefiningGeometry.Figures[0].Segments[i]).Point3;
  330. }
  331. if (tcnt == 1)
  332. {
  333. return ((BezierSegment)DefiningGeometry.Figures[0].Segments[i]).Point2;
  334. }
  335. else
  336. {
  337. return ((BezierSegment)DefiningGeometry.Figures[0].Segments[i]).Point1;
  338. }
  339. }
  340. else
  341. throw new NotImplementedException("Segmenttype is not jet implemented");
  342. //if (trackerNo - 2 >= 0 && trackerNo - 2 <= DefiningGeometry.Figures[0].Segments.Count)
  343. //{
  344. // if (DefiningGeometry.Figures[0].Segments[trackerNo - 2] is LineSegment)
  345. // return ((LineSegment)DefiningGeometry.Figures[0].Segments[trackerNo - 2]).Point;
  346. // else if(DefiningGeometry.Figures[0].Segments[trackerNo - 2] is QuadraticBezierSegment)
  347. // return ((QuadraticBezierSegment)DefiningGeometry.Figures[0].Segments[trackerNo - 2]).Point2;
  348. //}
  349. return DefiningGeometry.Figures[0].StartPoint;
  350. }
  351. public override System.Windows.Input.Cursor GetTrackerCursor(int trackerNo)
  352. {
  353. return System.Windows.Input.Cursors.SizeAll;
  354. }
  355. ///// <summary>
  356. ///// Hit test
  357. ///// </summary>
  358. ///// <param name="point"></param>
  359. ///// <returns></returns>
  360. //public override int HitTestInt(Point point)
  361. //{
  362. // if (IsSelected)
  363. // {
  364. // for (int i = 1; i <= TrackerCount; i++)
  365. // {
  366. // if (GetTrackerRectangle(i).Contains(point))
  367. // {
  368. // return i;
  369. // }
  370. // }
  371. // }
  372. // if (PointInObject(point))
  373. // return 0;
  374. // return -1;
  375. //}
  376. protected override bool PointInObject(Point point)
  377. {
  378. return DefiningGeometry.FillContains(point);
  379. }
  380. /// <summary>
  381. /// Move handle to new point (resizing)
  382. /// </summary>
  383. /// <param name="point"></param>
  384. /// <param name="trackerNo"></param>
  385. public override void MoveTracker(Point point, int trackerNo)
  386. {
  387. if (trackerNo == 1)
  388. DefiningGeometry.Figures[0].StartPoint = point;
  389. else
  390. {
  391. int ti = 0;
  392. int i = 0;
  393. int tcnt = 0;
  394. while (ti < trackerNo - 2)
  395. {
  396. if (DefiningGeometry.Figures[0].Segments[i] is LineSegment)
  397. {
  398. i++;
  399. }
  400. else if (DefiningGeometry.Figures[0].Segments[i] is QuadraticBezierSegment)
  401. {
  402. tcnt++;
  403. if (tcnt == 2)
  404. {
  405. i++;
  406. tcnt = 0;
  407. }
  408. }
  409. else if (DefiningGeometry.Figures[0].Segments[i] is BezierSegment)
  410. {
  411. tcnt++;
  412. if (tcnt == 3)
  413. {
  414. i++;
  415. tcnt = 0;
  416. }
  417. }
  418. else
  419. throw new NotImplementedException("Segmenttype is not jet implemented");
  420. ti++;
  421. }
  422. if (DefiningGeometry.Figures[0].Segments[i] is LineSegment)
  423. {
  424. ((LineSegment)DefiningGeometry.Figures[0].Segments[i]).Point = point;
  425. }
  426. else if (DefiningGeometry.Figures[0].Segments[i] is QuadraticBezierSegment)
  427. {
  428. if (tcnt == 1)
  429. {
  430. ((QuadraticBezierSegment)DefiningGeometry.Figures[0].Segments[i]).Point2 = point;
  431. }
  432. else
  433. {
  434. ((QuadraticBezierSegment)DefiningGeometry.Figures[0].Segments[i]).Point1 = point;
  435. }
  436. }
  437. else if (DefiningGeometry.Figures[0].Segments[i] is BezierSegment)
  438. {
  439. if (tcnt == 2)
  440. {
  441. ((BezierSegment)DefiningGeometry.Figures[0].Segments[i]).Point3 = point;
  442. }
  443. if (tcnt == 1)
  444. {
  445. ((BezierSegment)DefiningGeometry.Figures[0].Segments[i]).Point2 = point;
  446. }
  447. else
  448. {
  449. ((BezierSegment)DefiningGeometry.Figures[0].Segments[i]).Point1 = point;
  450. }
  451. }
  452. else
  453. throw new NotImplementedException("Segmenttype is not jet implemented");
  454. }
  455. this.Invalidate();
  456. CallChangedHandler();
  457. }
  458. public override void Move(double deltaX, double deltaY)
  459. {
  460. StartPoint = new Point(StartPoint.X + deltaX, StartPoint.Y + deltaY);
  461. foreach (PathSegment segment in DefiningGeometry.Figures[0].Segments)
  462. {
  463. if (segment is LineSegment)
  464. {
  465. ((LineSegment)segment).Point = new Point(
  466. ((LineSegment)segment).Point.X + deltaX,
  467. ((LineSegment)segment).Point.Y + deltaY);
  468. }
  469. else if (segment is QuadraticBezierSegment)
  470. {
  471. ((QuadraticBezierSegment)segment).Point1 = new Point(
  472. ((QuadraticBezierSegment)segment).Point1.X + deltaX,
  473. ((QuadraticBezierSegment)segment).Point1.Y + deltaY);
  474. ((QuadraticBezierSegment)segment).Point2 = new Point(
  475. ((QuadraticBezierSegment)segment).Point2.X + deltaX,
  476. ((QuadraticBezierSegment)segment).Point2.Y + deltaY);
  477. }
  478. else if (segment is BezierSegment)
  479. {
  480. ((BezierSegment)segment).Point1 = new Point(
  481. ((BezierSegment)segment).Point1.X + deltaX,
  482. ((BezierSegment)segment).Point1.Y + deltaY);
  483. ((BezierSegment)segment).Point2 = new Point(
  484. ((BezierSegment)segment).Point2.X + deltaX,
  485. ((BezierSegment)segment).Point2.Y + deltaY);
  486. ((BezierSegment)segment).Point3 = new Point(
  487. ((BezierSegment)segment).Point3.X + deltaX,
  488. ((BezierSegment)segment).Point3.Y + deltaY);
  489. }
  490. else
  491. throw new NotImplementedException("Segmenttype is not jet implemented");
  492. }
  493. this.Invalidate();
  494. CallMovedHandler();
  495. }
  496. #region IPoligonShape Member
  497. public void AddShapeToPoligon(PolygonShape poligon)
  498. {
  499. //TODO:
  500. //Flip the polygon if te first tracker is selected!
  501. if (SelectedTracker > 0)
  502. {
  503. foreach (PathSegment segment in DefiningGeometry.Figures[0].Segments)
  504. {
  505. if (segment is LineSegment)
  506. {
  507. poligon.AddSegment(new LineSegment(
  508. ((LineSegment)segment).Point,
  509. true),
  510. new Point());
  511. }
  512. else if (segment is QuadraticBezierSegment)
  513. {
  514. poligon.AddSegment(new QuadraticBezierSegment(
  515. ((QuadraticBezierSegment)segment).Point1,
  516. ((QuadraticBezierSegment)segment).Point2,
  517. true),
  518. new Point());
  519. }
  520. else if (segment is BezierSegment)
  521. {
  522. poligon.AddSegment(new BezierSegment(
  523. ((BezierSegment)segment).Point1,
  524. ((BezierSegment)segment).Point2,
  525. ((BezierSegment)segment).Point3,
  526. true),
  527. new Point());
  528. }
  529. else
  530. throw new ShapeException("Segmenttype is not jet implemented");
  531. }
  532. }
  533. else
  534. throw new ShapeException("No Tracker is isSelected");
  535. }
  536. public PolygonShape CreatePolygon()
  537. {
  538. return this;
  539. }
  540. #endregion
  541. #region IHistoryable Members
  542. public ShapeMemento CreateMementoState()
  543. {
  544. var memento = new PolygonMemento();
  545. memento.SaveProperties(this);
  546. //foreach (PathSegment segment in DefiningGeometry.Figures[0].Segments)
  547. //{
  548. // if (segment is LineSegment)
  549. // {
  550. // ((PolygonMemento)memento).Segments.Add(new LineSegment(
  551. // ((LineSegment)segment).Point,
  552. // ((LineSegment)segment).IsStroked));
  553. // }
  554. // else if (segment is QuadraticBezierSegment)
  555. // {
  556. // ((PolygonMemento)memento).Segments.Add(new QuadraticBezierSegment(
  557. // ((QuadraticBezierSegment)segment).Point1,
  558. // ((QuadraticBezierSegment)segment).Point2,
  559. // ((QuadraticBezierSegment)segment).IsStroked));
  560. // }
  561. // else if (segment is BezierSegment)
  562. // {
  563. // ((PolygonMemento)memento).Segments.Add(new BezierSegment(
  564. // ((BezierSegment)segment).Point1,
  565. // ((BezierSegment)segment).Point2,
  566. // ((BezierSegment)segment).Point2,
  567. // ((BezierSegment)segment).IsStroked));
  568. // }
  569. // else
  570. // throw new NotImplementedException("Segmenttype is not jet implemented");
  571. //}
  572. return memento;
  573. }
  574. public void ResetState(ShapeMemento memento)
  575. {
  576. memento.ResetProperties(this);
  577. //DefiningGeometry.Figures[0].Segments.Clear();
  578. //foreach (PathSegment segment in ((PolygonMemento)memento).Segments)
  579. //{
  580. // if (segment is LineSegment)
  581. // {
  582. // DefiningGeometry.Figures[0].Segments.Add(new LineSegment(
  583. // ((LineSegment)segment).Point,
  584. // ((LineSegment)segment).IsStroked));
  585. // }
  586. // else if (segment is QuadraticBezierSegment)
  587. // {
  588. // DefiningGeometry.Figures[0].Segments.Add(new QuadraticBezierSegment(
  589. // ((QuadraticBezierSegment)segment).Point1,
  590. // ((QuadraticBezierSegment)segment).Point2,
  591. // ((QuadraticBezierSegment)segment).IsStroked));
  592. // }
  593. // else if (segment is BezierSegment)
  594. // {
  595. // DefiningGeometry.Figures[0].Segments.Add(new BezierSegment(
  596. // ((BezierSegment)segment).Point1,
  597. // ((BezierSegment)segment).Point2,
  598. // ((BezierSegment)segment).Point2,
  599. // ((BezierSegment)segment).IsStroked));
  600. // }
  601. // else
  602. // throw new NotImplementedException("Segmenttype is not jet implemented");
  603. //}
  604. }
  605. #endregion
  606. public override void MoveTracker(int tracker, double deltaX, double deltaY)
  607. {
  608. //throw new NotImplementedException();
  609. if (tracker == 1)
  610. DefiningGeometry.Figures[0].StartPoint = new Point(DefiningGeometry.Figures[0].StartPoint.X + deltaX, DefiningGeometry.Figures[0].StartPoint.Y + deltaY);
  611. else
  612. {
  613. int ti = 0;
  614. int i = 0;
  615. int tcnt = 0;
  616. while (ti < tracker - 2)
  617. {
  618. if (DefiningGeometry.Figures[0].Segments[i] is LineSegment)
  619. {
  620. i++;
  621. }
  622. else if (DefiningGeometry.Figures[0].Segments[i] is QuadraticBezierSegment)
  623. {
  624. tcnt++;
  625. if (tcnt == 2)
  626. {
  627. i++;
  628. tcnt = 0;
  629. }
  630. }
  631. else if (DefiningGeometry.Figures[0].Segments[i] is BezierSegment)
  632. {
  633. tcnt++;
  634. if (tcnt == 3)
  635. {
  636. i++;
  637. tcnt = 0;
  638. }
  639. }
  640. else
  641. throw new NotImplementedException("Segmenttype is not jet implemented");
  642. ti++;
  643. }
  644. if (DefiningGeometry.Figures[0].Segments[i] is LineSegment)
  645. {
  646. Point point = ((LineSegment)DefiningGeometry.Figures[0].Segments[i]).Point;
  647. ((LineSegment)DefiningGeometry.Figures[0].Segments[i]).Point = new Point(point.X + deltaX, point.Y + deltaY);
  648. }
  649. else if (DefiningGeometry.Figures[0].Segments[i] is QuadraticBezierSegment)
  650. {
  651. if (tcnt == 1)
  652. {
  653. Point point = ((QuadraticBezierSegment)DefiningGeometry.Figures[0].Segments[i]).Point2;
  654. ((QuadraticBezierSegment)DefiningGeometry.Figures[0].Segments[i]).Point2 = new Point(point.X + deltaX, point.Y + deltaY);
  655. }
  656. else
  657. {
  658. Point point = ((QuadraticBezierSegment)DefiningGeometry.Figures[0].Segments[i]).Point1;
  659. ((QuadraticBezierSegment)DefiningGeometry.Figures[0].Segments[i]).Point1 = new Point(point.X + deltaX, point.Y + deltaY);
  660. }
  661. }
  662. else if (DefiningGeometry.Figures[0].Segments[i] is BezierSegment)
  663. {
  664. if (tcnt == 2)
  665. {
  666. Point point = ((BezierSegment)DefiningGeometry.Figures[0].Segments[i]).Point3;
  667. ((BezierSegment)DefiningGeometry.Figures[0].Segments[i]).Point3 = new Point(point.X + deltaX, point.Y + deltaY);
  668. }
  669. if (tcnt == 1)
  670. {
  671. Point point = ((BezierSegment)DefiningGeometry.Figures[0].Segments[i]).Point2;
  672. ((BezierSegment)DefiningGeometry.Figures[0].Segments[i]).Point2 = new Point(point.X + deltaX, point.Y + deltaY);
  673. }
  674. else
  675. {
  676. Point point = ((BezierSegment)DefiningGeometry.Figures[0].Segments[i]).Point1;
  677. ((BezierSegment)DefiningGeometry.Figures[0].Segments[i]).Point1 = new Point(point.X + deltaX, point.Y + deltaY);
  678. }
  679. }
  680. else
  681. throw new NotImplementedException("Segmenttype is not jet implemented");
  682. }
  683. this.Invalidate();
  684. CallChangedHandler();
  685. }
  686. #region ICopyable Members
  687. public VectorShape Copy()
  688. {
  689. var shape = new PolygonShape(StartPoint);
  690. foreach (PathSegment segment in DefiningGeometry.Figures[0].Segments)
  691. {
  692. if (segment is LineSegment)
  693. {
  694. shape.AddSegment(new LineSegment(
  695. ((LineSegment)segment).Point,
  696. true),
  697. new Point());
  698. }
  699. else if (segment is QuadraticBezierSegment)
  700. {
  701. shape.AddSegment(new QuadraticBezierSegment(
  702. ((QuadraticBezierSegment)segment).Point1,
  703. ((QuadraticBezierSegment)segment).Point2,
  704. true),
  705. new Point());
  706. }
  707. else if (segment is BezierSegment)
  708. {
  709. shape.AddSegment(new BezierSegment(
  710. ((BezierSegment)segment).Point1,
  711. ((BezierSegment)segment).Point2,
  712. ((BezierSegment)segment).Point3,
  713. true),
  714. new Point());
  715. }
  716. else
  717. throw new ShapeException("Segmenttype is not jet implemented");
  718. }
  719. shape.Fill = this.Fill;
  720. shape.Stroke = this.Stroke;
  721. shape.StrokeThickness = this.StrokeThickness;
  722. return shape;
  723. }
  724. #endregion
  725. }
  726. }