src/geometry.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
   2 /*
   3  * geometry.cpp: Geometry classes
   4  *
   5  * Contact:
   6  *   Moonlight List (moonlight-list@lists.ximian.com)
   7  *
   8  * Copyright 2007 Novell, Inc. (http://www.novell.com)
   9  *
  10  * See the LICENSE file included with the distribution for details.
  11  *
  12  */
  13
  14 #include <config.h>
  15
  16 #include <math.h>
  17
  18 #include "utils.h"
  19 #include "geometry.h"
  20 #include "shape.h"
  21
  22 //
  23 // Geometry
  24 //
  25
  26 Geometry::Geometry ()
  27 {
  28         SetObjectType (Type::GEOMETRY);
  29
  30         path = NULL;
  31         local_bounds = Rect (0,0, -INFINITY, -INFINITY);
  32 }
  33
  34 Geometry::~Geometry ()
  35 {
  36         if (path)
  37                 moon_path_destroy (path);
  38 }
  39
  40 void
  41 Geometry::Draw (cairo_t *cr)
  42 {
  43         Transform *transform = GetTransform ();
  44         cairo_matrix_t saved;
  45         cairo_get_matrix (cr, &saved);
  46
  47         if (transform) {
  48                 cairo_matrix_t matrix;
  49                 transform->GetTransform (&matrix);
  50                 cairo_transform (cr, &matrix);
  51         }
  52
  53         if (!IsBuilt ())
  54                 Build ();
  55
  56         // Geometry is used for Clip so Fill (normally setting the fill rule) is never called
  57         cairo_set_fill_rule (cr, convert_fill_rule (GetFillRule ()));
  58
  59         if (path)
  60                 cairo_append_path (cr, &path->cairo);
  61
  62         cairo_set_matrix (cr, &saved);
  63 }
  64
  65 void
  66 Geometry::InvalidateCache ()
  67 {
  68         if (path)
  69                 moon_path_clear (path);
  70
  71         local_bounds = Rect (0, 0, -INFINITY, -INFINITY);
  72 }
  73
  74 Rect
  75 Geometry::GetBounds ()
  76 {
  77         bool compute = local_bounds.IsEmpty (true);
  78
  79         if (!IsBuilt ()) {
  80                 Build ();
  81                 compute = true;
  82         }
  83
  84         if (compute)
  85                 local_bounds = ComputePathBounds ();
  86
  87         Rect bounds = local_bounds;
  88
  89         Transform *transform = GetTransform ();
  90         if (transform) {
  91                 cairo_matrix_t matrix;
  92                 transform->GetTransform (&matrix);
  93                 bounds = bounds.Transform (&matrix);
  94         }
  95
  96         return bounds;
  97 }
  98
  99 Rect
 100 Geometry::ComputePathBounds()
 101 {
 102         if (!IsBuilt ())
 103                 Build ();
 104
 105         if (!path || (path->cairo.num_data == 0))
 106                 return Rect ();
 107
 108         cairo_t *cr = measuring_context_create ();
 109
 110         cairo_append_path (cr, &path->cairo);
 111
 112         double x1, y1, x2, y2;
 113
 114         cairo_path_extents (cr, &x1, &y1, &x2, &y2);
 115
 116         Rect bounds = Rect (MIN (x1, x2), MIN (y1, y2), fabs (x2 - x1), fabs (y2 - y1));
 117
 118         measuring_context_destroy (cr);
 119
 120         return bounds;
 121 }
 122
 123 void
 124 Geometry::OnPropertyChanged (PropertyChangedEventArgs *args, MoonError *error)
 125 {
 126         // no need to clear the path for Geometry itself as FillRule and Transform properties are
 127         // only used when drawing, i.e. they do not affect the path itself
 128         if (args->GetProperty ()->GetOwnerType() != Type::GEOMETRY &&
 129                 args->GetId () != PathGeometry::FillRuleProperty &&
 130                 args->GetId () != GeometryGroup::FillRuleProperty) {
 131                 DependencyObject::OnPropertyChanged (args, error);
 132
 133                 // not sure why we're doing this inside this block.. seems like it should happen outside it?
 134                 InvalidateCache ();
 135
 136                 return;
 137         }
 138
 139         NotifyListenersOfPropertyChange (args, error);
 140 }
 141
 142 void
 143 Geometry::OnSubPropertyChanged (DependencyProperty *prop, DependencyObject *obj, PropertyChangedEventArgs *subobj_args)
 144 {
 145         NotifyListenersOfPropertyChange (prop, NULL);
 146
 147         DependencyObject::OnSubPropertyChanged (prop, obj, subobj_args);
 148 }
 149
 150 //
 151 // GeometryCollection
 152 //
 153
 154 GeometryCollection::GeometryCollection ()
 155 {
 156         SetObjectType (Type::GEOMETRY_COLLECTION);
 157 }
 158
 159 GeometryCollection::~GeometryCollection ()
 160 {
 161 }
 162
 163 //
 164 // GeometryGroup
 165 //
 166
 167 GeometryGroup::GeometryGroup ()
 168 {
 169         SetObjectType (Type::GEOMETRYGROUP);
 170 }
 171
 172 GeometryGroup::~GeometryGroup ()
 173 {
 174 }
 175
 176 void
 177 GeometryGroup::OnCollectionChanged (Collection *col, CollectionChangedEventArgs *args)
 178 {
 179         InvalidateCache ();
 180
 181         if (col != GetChildren ()) {
 182                 Geometry::OnCollectionChanged (col, args);
 183                 return;
 184         }
 185
 186         NotifyListenersOfPropertyChange (GeometryGroup::ChildrenProperty, NULL);
 187 }
 188
 189 void
 190 GeometryGroup::OnCollectionItemChanged (Collection *col, DependencyObject *obj, PropertyChangedEventArgs *args)
 191 {
 192         InvalidateCache ();
 193
 194         if (col != GetChildren ()) {
 195                 Geometry::OnCollectionItemChanged (col, obj, args);
 196                 return;
 197         }
 198
 199         NotifyListenersOfPropertyChange (GeometryGroup::ChildrenProperty, NULL);
 200 }
 201
 202 void
 203 GeometryGroup::Draw (cairo_t *cr)
 204 {
 205         Transform *transform = GetTransform ();
 206         cairo_matrix_t saved;
 207         cairo_get_matrix (cr, &saved);
 208
 209         if (transform) {
 210                 cairo_matrix_t matrix;
 211                 transform->GetTransform (&matrix);
 212                 cairo_transform (cr, &matrix);
 213         }
 214
 215         GeometryCollection *children = GetChildren ();
 216         Geometry *geometry;
 217
 218         // GeometryGroup is used for Clip (as a Geometry) so Fill (normally setting the fill rule) is never called
 219         cairo_set_fill_rule (cr, convert_fill_rule (GetFillRule ()));
 220
 221         for (int i = 0; i < children->GetCount (); i++) {
 222                 geometry = children->GetValueAt (i)->AsGeometry ();
 223
 224                 geometry->Draw (cr);
 225         }
 226
 227         cairo_set_matrix (cr, &saved);
 228 }
 229
 230 Rect
 231 GeometryGroup::ComputePathBounds ()
 232 {
 233         GeometryCollection *children = GetChildren ();
 234         Rect bounds = Rect (0.0, 0.0, 0.0, 0.0);
 235         Geometry *geometry;
 236
 237         for (int i = 0; i < children->GetCount (); i++) {
 238                 geometry = children->GetValueAt (i)->AsGeometry ();
 239
 240                 bounds = bounds.Union (geometry->GetBounds (), true);
 241         }
 242
 243         //g_warning ("GeometryGroup::ComputeBounds - x %g y %g w %g h %g", bounds.x, bounds.y, bounds.w, bounds.h);
 244         return bounds;
 245 }
 246
 247 #if 0
 248 Point
 249 Geometry::GetOriginPoint ()
 250 {
 251         double x = 0.0;
 252         double y = 0.0;
 253
 254         if (!IsBuilt ())
 255                 Build ();
 256
 257         moon_get_origin (path, &x, &y);
 258         return Point (x, y);
 259 }
 260 #endif
 261
 262 //
 263 // EllipseGeometry
 264 //
 265
 266 EllipseGeometry::EllipseGeometry ()
 267 {
 268         SetObjectType (Type::ELLIPSEGEOMETRY);
 269 }
 270
 271 EllipseGeometry::~EllipseGeometry ()
 272 {
 273 }
 274
 275 void
 276 EllipseGeometry::Build ()
 277 {
 278         double rx = GetRadiusX ();
 279         double ry = GetRadiusY ();
 280         Point *pt = GetCenter ();
 281         double x = pt ? pt->x : 0.0;
 282         double y = pt ? pt->y : 0.0;
 283
 284         path = moon_path_renew (path, MOON_PATH_ELLIPSE_LENGTH);
 285         moon_ellipse (path, x - rx, y - ry, rx * 2.0, ry * 2.0);
 286 }
 287
 288 Rect
 289 EllipseGeometry::ComputePathBounds ()
 290 {
 291         // code written to minimize divisions
 292
 293         double hw = GetRadiusX ();
 294         double hh = GetRadiusY ();
 295         // point is at center, so left-top corner is minus half width / half height
 296         Point *pt = GetCenter ();
 297         double x = pt ? pt->x : 0.0;
 298         double y = pt ? pt->y : 0.0;
 299         Rect bounds;
 300
 301         bounds = Rect (x - hw, y - hh, hw * 2.0, hh * 2.0);
 302
 303         return bounds;
 304 }
 305
 306 //
 307 // LineGeometry
 308 //
 309
 310 LineGeometry::LineGeometry ()
 311 {
 312         SetObjectType (Type::LINEGEOMETRY);
 313 }
 314
 315 LineGeometry::~LineGeometry ()
 316 {
 317 }
 318
 319 void
 320 LineGeometry::Build ()
 321 {
 322         Point *p1 = GetStartPoint ();
 323         Point *p2 = GetEndPoint ();
 324
 325         path = moon_path_renew (path, MOON_PATH_MOVE_TO_LENGTH + MOON_PATH_LINE_TO_LENGTH);
 326         moon_move_to (path, p1 ? p1->x : 0.0, p1 ? p1->y : 0.0);
 327         moon_line_to (path, p2 ? p2->x : 0.0, p2 ? p2->y : 0.0);
 328 }
 329
 330 Rect
 331 LineGeometry::ComputePathBounds ()
 332 {
 333         Point *p1 = GetStartPoint ();
 334         Point *p2 = GetEndPoint ();
 335         PenLineCap start_cap;
 336         PenLineCap end_cap;
 337         Rect bounds;
 338
 339         start_cap = PenLineCapFlat;
 340         end_cap = PenLineCapFlat;
 341
 342         calc_line_bounds (p1 ? p1->x : 0.0,
 343                           p2 ? p2->x : 0.0,
 344                           p1 ? p1->y : 0.0,
 345                           p2 ? p2->y : 0.0,
 346                           0.0,
 347                           start_cap,
 348                           end_cap,
 349                           &bounds);
 350
 351         return bounds;
 352 }
 353
 354 //
 355 // PathFigureCollection
 356 //
 357
 358 PathFigureCollection::PathFigureCollection ()
 359 {
 360         SetObjectType (Type::PATHFIGURE_COLLECTION);
 361 }
 362
 363 PathFigureCollection::~PathFigureCollection ()
 364 {
 365 }
 366
 367 //
 368 // PathGeometry
 369 //
 370
 371 PathGeometry::PathGeometry ()
 372 {
 373         SetObjectType (Type::PATHGEOMETRY);
 374 }
 375
 376 PathGeometry::~PathGeometry ()
 377 {
 378 }
 379
 380 // special case for the XAML parser when Path Markup Language (PML) is being used
 381 PathGeometry::PathGeometry (moon_path *pml)
 382 {
 383         SetObjectType (Type::PATHGEOMETRY);
 384         path = pml;
 385 }
 386
 387 void
 388 PathGeometry::OnCollectionChanged (Collection *col, CollectionChangedEventArgs *args)
 389 {
 390         if (col != GetFigures ()) {
 391                 Geometry::OnCollectionChanged (col, args);
 392                 return;
 393         }
 394
 395         InvalidateCache ();
 396
 397         NotifyListenersOfPropertyChange (PathGeometry::FiguresProperty, NULL);
 398 }
 399
 400 void
 401 PathGeometry::OnCollectionItemChanged (Collection *col, DependencyObject *obj, PropertyChangedEventArgs *args)
 402 {
 403         if (col != GetFigures ()) {
 404                 Geometry::OnCollectionItemChanged (col, obj, args);
 405                 return;
 406         }
 407
 408         InvalidateCache ();
 409
 410         NotifyListenersOfPropertyChange (PathGeometry::FiguresProperty, NULL);
 411 }
 412
 413 void
 414 PathGeometry::Build ()
 415 {
 416         PathFigureCollection *figures;
 417         PathFigure *figure;
 418
 419         path = moon_path_renew (path, 0);
 420
 421         if (!(figures = GetFigures ()))
 422                 return;
 423
 424         for (int i = 0; i < figures->GetCount (); i++) {
 425                 figure = figures->GetValueAt (i)->AsPathFigure ();
 426
 427                 if (!figure->IsBuilt ())
 428                         figure->Build ();
 429
 430                 moon_merge (path, figure->path);
 431         }
 432 }
 433
 434 Rect
 435 PathGeometry::ComputePathBounds ()
 436 {
 437         if (!IsBuilt ())
 438                 Build ();
 439
 440         PathFigureCollection *figures = GetFigures ();
 441         if (!figures && (!path || (path->cairo.num_data == 0)))
 442                 return Rect ();
 443
 444         cairo_t *cr = measuring_context_create ();
 445
 446         cairo_append_path (cr, &path->cairo);
 447
 448         double x1, y1, x2, y2;
 449
 450         cairo_path_extents (cr, &x1, &y1, &x2, &y2);
 451
 452         Rect bounds = Rect (MIN (x1, x2), MIN (y1, y2), fabs (x2 - x1), fabs (y2 - y1));
 453
 454         measuring_context_destroy (cr);
 455
 456         return bounds;
 457 }
 458
 459 //
 460 // RectangleGeometry
 461 //
 462
 463 RectangleGeometry::RectangleGeometry ()
 464 {
 465         SetObjectType (Type::RECTANGLEGEOMETRY);
 466 }
 467
 468 RectangleGeometry::~RectangleGeometry ()
 469 {
 470 }
 471
 472 void
 473 RectangleGeometry::Build ()
 474 {
 475         Rect *rect = GetRect ();
 476         if (!rect)
 477                 return;
 478
 479         double radius_x = GetRadiusX ();
 480         double radius_y = GetRadiusY ();
 481         path = moon_path_renew (path, MOON_PATH_ROUNDED_RECTANGLE_LENGTH);
 482         moon_rounded_rectangle (path, rect->x, rect->y, rect->width, rect->height, radius_x, radius_y);
 483 }
 484
 485 Rect
 486 RectangleGeometry::ComputePathBounds ()
 487 {
 488         Rect *rect = GetRect ();
 489         Rect bounds;
 490
 491         if (!rect)
 492                 return Rect (0.0, 0.0, 0.0, 0.0);
 493
 494         bounds = *rect;
 495
 496         return bounds;
 497 }
 498
 499 //
 500 // PathSegmentCollection
 501 //
 502
 503 PathSegmentCollection::PathSegmentCollection ()
 504 {
 505         SetObjectType (Type::PATHSEGMENT_COLLECTION);
 506 }
 507
 508 PathSegmentCollection::~PathSegmentCollection ()
 509 {
 510 }
 511
 512 //
 513 // PathFigure
 514 //
 515
 516 PathFigure::PathFigure ()
 517 {
 518         SetObjectType (Type::PATHFIGURE);
 519         path = NULL;
 520 }
 521
 522 PathFigure::~PathFigure ()
 523 {
 524         if (path)
 525                 moon_path_destroy (path);
 526 }
 527
 528 void
 529 PathFigure::OnPropertyChanged (PropertyChangedEventArgs *args, MoonError *error)
 530 {
 531         if (args->GetProperty ()->GetOwnerType() != Type::PATHFIGURE) {
 532                 DependencyObject::OnPropertyChanged (args, error);
 533                 return;
 534         }
 535
 536         if (path)
 537                 moon_path_clear (path);
 538
 539         NotifyListenersOfPropertyChange (args, error);
 540 }
 541
 542 void
 543 PathFigure::OnCollectionChanged (Collection *col, CollectionChangedEventArgs *args)
 544 {
 545         if (col != GetSegments ()) {
 546                 DependencyObject::OnCollectionChanged (col, args);
 547                 return;
 548         }
 549
 550         if (path)
 551                 moon_path_clear (path);
 552
 553         NotifyListenersOfPropertyChange (PathFigure::SegmentsProperty, NULL);
 554 }
 555
 556 void
 557 PathFigure::OnCollectionItemChanged (Collection *col, DependencyObject *obj, PropertyChangedEventArgs *args)
 558 {
 559         if (col != GetSegments ()) {
 560                 DependencyObject::OnCollectionItemChanged (col, obj, args);
 561                 return;
 562         }
 563
 564         if (path)
 565                 moon_path_clear (path);
 566
 567         NotifyListenersOfPropertyChange (PathFigure::SegmentsProperty, NULL);
 568 }
 569
 570 void
 571 PathFigure::Build ()
 572 {
 573         PathSegmentCollection *segments = GetSegments ();
 574         PathSegment *segment;
 575
 576         if (path)
 577                 moon_path_clear (path);
 578         else
 579                 path = moon_path_new (MOON_PATH_MOVE_TO_LENGTH + (segments->GetCount () * 4) + MOON_PATH_CLOSE_PATH_LENGTH);
 580
 581         Point *start = GetStartPoint ();
 582         moon_move_to (path, start ? start->x : 0.0, start ? start->y : 0.0);
 583
 584         for (int i = 0; i < segments->GetCount (); i++) {
 585                 segment = segments->GetValueAt (i)->AsPathSegment ();
 586
 587                 segment->Append (path);
 588         }
 589
 590         if (GetIsClosed ())
 591                 moon_close_path (path);
 592 }
 593
 594 //
 595 // PathSegment
 596 //
 597
 598 PathSegment::PathSegment ()
 599 {
 600         SetObjectType (Type::PATHSEGMENT);
 601 }
 602
 603 PathSegment::~PathSegment ()
 604 {
 605 }
 606
 607 void
 608 PathSegment::Build ()
 609 {
 610 }
 611
 612 void
 613 PathSegment::Append (moon_path *path)
 614 {
 615 }
 616
 617 //
 618 // ArcSegment
 619 //
 620
 621 ArcSegment::ArcSegment ()
 622 {
 623         SetObjectType (Type::ARCSEGMENT);
 624 }
 625
 626 ArcSegment::~ArcSegment ()
 627 {
 628 }
 629
 630 void
 631 ArcSegment::Append (moon_path *path)
 632 {
 633         Size *size = GetSize ();
 634         double width = size ? size->width : 0.0;
 635         double height = size ? size->height : 0.0;
 636
 637         Point *end_point = GetPoint ();
 638         double ex = end_point ? end_point->x : 0.0;
 639         double ey = end_point ? end_point->y : 0.0;
 640
 641         moon_arc_to (path, width, height, GetRotationAngle (), GetIsLargeArc (), GetSweepDirection (), ex, ey);
 642 }
 643
 644 //
 645 // BezierSegment
 646 //
 647
 648 BezierSegment::BezierSegment ()
 649 {
 650         SetObjectType (Type::BEZIERSEGMENT);
 651 }
 652
 653 BezierSegment::~BezierSegment ()
 654 {
 655 }
 656
 657 void
 658 BezierSegment::Append (moon_path *path)
 659 {
 660         Point *p1 = GetPoint1 ();
 661         Point *p2 = GetPoint2 ();
 662         Point *p3 = GetPoint3 ();
 663
 664         double x1 = p1 ? p1->x : 0.0;
 665         double y1 = p1 ? p1->y : 0.0;
 666         double x2 = p2 ? p2->x : 0.0;
 667         double y2 = p2 ? p2->y : 0.0;
 668         double x3 = p3 ? p3->x : 0.0;
 669         double y3 = p3 ? p3->y : 0.0;
 670
 671         moon_curve_to (path, x1, y1, x2, y2, x3, y3);
 672 }
 673
 674 //
 675 // LineSegment
 676 //
 677
 678 LineSegment::LineSegment ()
 679 {
 680         SetObjectType (Type::LINESEGMENT);
 681 }
 682
 683 LineSegment::~LineSegment ()
 684 {
 685 }
 686
 687 void
 688 LineSegment::Append (moon_path *path)
 689 {
 690         Point *p = GetPoint ();
 691
 692         double x = p ? p->x : 0.0;
 693         double y = p ? p->y : 0.0;
 694
 695         moon_line_to (path, x, y);
 696 }
 697
 698 //
 699 // PolyBezierSegment
 700 //
 701
 702 PolyBezierSegment::PolyBezierSegment ()
 703 {
 704         SetObjectType (Type::POLYBEZIERSEGMENT);
 705 }
 706
 707 PolyBezierSegment::~PolyBezierSegment ()
 708 {
 709 }
 710
 711 void
 712 PolyBezierSegment::Append (moon_path *path)
 713 {
 714         PointCollection *col;
 715         GPtrArray *points;
 716
 717         col = GetPoints ();
 718
 719         // we need at least 3 points
 720         if (!col || (col->GetCount() % 3) != 0)
 721                 return;
 722
 723         points = col->Array();
 724
 725         for (int i = 0; i < col->GetCount() - 2; i += 3) {
 726                 moon_curve_to (path,
 727                                ((Value*)g_ptr_array_index(points, i))->AsPoint()->x,
 728                                ((Value*)g_ptr_array_index(points, i))->AsPoint()->y,
 729
 730                                ((Value*)g_ptr_array_index(points, i+1))->AsPoint()->x,
 731                                ((Value*)g_ptr_array_index(points, i+1))->AsPoint()->y,
 732
 733                                ((Value*)g_ptr_array_index(points, i+2))->AsPoint()->x,
 734                                ((Value*)g_ptr_array_index(points, i+2))->AsPoint()->y);
 735         }
 736 }
 737
 738 int
 739 PolyBezierSegment::GetPathSize ()
 740 {
 741         PointCollection *points = GetPoints ();
 742         int n = points ? points->GetCount() : 0;
 743
 744         return (n / 3) * MOON_PATH_CURVE_TO_LENGTH;
 745 }
 746
 747 //
 748 // PolyLineSegment
 749 //
 750
 751 PolyLineSegment::PolyLineSegment ()
 752 {
 753         SetObjectType (Type::POLYLINESEGMENT);
 754 }
 755
 756 PolyLineSegment::~PolyLineSegment ()
 757 {
 758 }
 759
 760 void
 761 PolyLineSegment::Append (moon_path *path)
 762 {
 763         PointCollection *col;
 764         GPtrArray *points;
 765
 766         col = GetPoints ();
 767
 768         if (!col)
 769                 return;
 770
 771         points = col->Array();
 772
 773         for (int i = 0; i < col->GetCount(); i++)
 774                 moon_line_to (path,
 775                               ((Value*)g_ptr_array_index(points, i))->AsPoint()->x,
 776                               ((Value*)g_ptr_array_index(points, i))->AsPoint()->y);
 777 }
 778
 779 int
 780 PolyLineSegment::GetPathSize ()
 781 {
 782         PointCollection *points = GetPoints ();
 783         int n = points ? points->GetCount() : 0;
 784
 785         return n * MOON_PATH_LINE_TO_LENGTH;
 786 }
 787
 788 //
 789 // PolyQuadraticBezierSegment
 790 //
 791
 792 // quadratic to cubic bezier, the original control point and the end control point are the same
 793 // http://web.archive.org/web/20020209100930/http://www.icce.rug.nl/erikjan/bluefuzz/beziers/beziers/node2.html
 794 //
 795 // note: we dont call moon_quad_curve_to to avoid calling moon_get_current_point
 796 // on each curve (since all but the first one is known)
 797
 798 PolyQuadraticBezierSegment::PolyQuadraticBezierSegment ()
 799 {
 800         SetObjectType (Type::POLYQUADRATICBEZIERSEGMENT);
 801 }
 802
 803 PolyQuadraticBezierSegment::~PolyQuadraticBezierSegment ()
 804 {
 805 }
 806
 807 void
 808 PolyQuadraticBezierSegment::Append (moon_path *path)
 809 {
 810         PointCollection *col;
 811         GPtrArray *points;
 812
 813         col = GetPoints ();
 814
 815         if (!col || ((col->GetCount() % 2) != 0))
 816                 return;
 817
 818         // origin
 819         double x0 = 0.0;
 820         double y0 = 0.0;
 821         moon_get_current_point (path, &x0, &y0);
 822
 823         points = col->Array();
 824
 825         // we need at least 2 points
 826         for (int i = 0; i < col->GetCount() - 1; i+=2) {
 827                 double x1 = ((Value*)g_ptr_array_index(points, i))->AsPoint()->x;
 828                 double y1 = ((Value*)g_ptr_array_index(points, i))->AsPoint()->y;
 829                 double x2 = ((Value*)g_ptr_array_index(points, i+1))->AsPoint()->x;
 830                 double y2 = ((Value*)g_ptr_array_index(points, i+1))->AsPoint()->y;
 831                 double x3 = x2;
 832                 double y3 = y2;
 833
 834                 x2 = x1 + (x2 - x1) / 3;
 835                 y2 = y1 + (y2 - y1) / 3;
 836                 x1 = x0 + 2 * (x1 - x0) / 3;
 837                 y1 = y0 + 2 * (y1 - y0) / 3;
 838
 839                 moon_curve_to (path, x1, y1, x2, y2, x3, y3);
 840
 841                 // set new origin
 842                 x0 = x3;
 843                 y0 = y3;
 844         }
 845 }
 846
 847 int
 848 PolyQuadraticBezierSegment::GetPathSize ()
 849 {
 850         PointCollection* points = GetPoints ();
 851
 852         int n = points ? points->GetCount() : 0;
 853
 854         return (n / 2) * MOON_PATH_CURVE_TO_LENGTH;
 855 }
 856
 857 //
 858 // QuadraticBezierSegment
 859 //
 860
 861 QuadraticBezierSegment::QuadraticBezierSegment ()
 862 {
 863         SetObjectType (Type::QUADRATICBEZIERSEGMENT);
 864 }
 865
 866 QuadraticBezierSegment::~QuadraticBezierSegment ()
 867 {
 868 }
 869
 870 void
 871 QuadraticBezierSegment::Append (moon_path *path)
 872 {
 873         Point *p1 = GetPoint1 ();
 874         Point *p2 = GetPoint2 ();
 875
 876         double x1 = p1 ? p1->x : 0.0;
 877         double y1 = p1 ? p1->y : 0.0;
 878         double x2 = p2 ? p2->x : 0.0;
 879         double y2 = p2 ? p2->y : 0.0;
 880
 881         moon_quad_curve_to (path, x1, y1, x2, y2);
 882 }