contrib/src/canvas/polygon.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        polygon.cpp
   3 // Author:      Klaas Holwerda
   4 // Created:     XX/XX/XX
   5 // Copyright:   2000 (c) Klaas Holwerda
   6 // Licence:     wxWindows Licence
   7 /////////////////////////////////////////////////////////////////////////////
   8
   9 #ifdef __GNUG__
  10     #pragma implementation "polygon.cpp"
  11 #endif
  12
  13 // For compilers that support precompilation, includes "wx/wx.h".
  14 #include "wx/wxprec.h"
  15
  16 #ifdef __BORLANDC__
  17     #pragma hdrstop
  18 #endif
  19
  20 #include "wx/canvas/polygon.h"
  21 #include "wx/canvas/liner.h"
  22
  23 void ConvertSplinedPolygon(wxList* list, double Aber);
  24 void ConvertSplinedPolyline(wxList* list,double Aber);
  25 void ConvertSplinedPolygon(int& n, wxPoint2DDouble* points[], double Aber);
  26 static void GetLRO(const wxPoint2DDouble& P, const wxPoint2DDouble& p1, const wxPoint2DDouble& p2, int &LRO1, int &LRO2,const double marge);
  27
  28 //----------------------------------------------------------------------------
  29 // wxCanvasPolyline
  30 //----------------------------------------------------------------------------
  31
  32 wxCanvasPolyline::wxCanvasPolyline( int n,  wxPoint2DDouble points[])
  33    : wxCanvasObject()
  34 {
  35     m_n = n;
  36     m_points = points;
  37     m_pen = *wxBLACK_PEN;
  38
  39     CalcBoundingBox();
  40 }
  41
  42 wxCanvasPolyline::~wxCanvasPolyline()
  43 {
  44     delete m_points;
  45 }
  46
  47 void wxCanvasPolyline::SetPosXY( double x, double y)
  48 {
  49     double xo=m_points[0].m_x;
  50     double yo=m_points[0].m_y;
  51     int i;
  52     for (i=0; i < m_n;i++)
  53     {
  54         m_points[i].m_x += (x-xo);
  55         m_points[i].m_y += (y-yo);
  56     }
  57     CalcBoundingBox();
  58 }
  59
  60 void wxCanvasPolyline::TransLate( double x, double y )
  61 {
  62     int i;
  63     for (i=0; i < m_n;i++)
  64     {
  65         m_points[i].m_x += x;
  66         m_points[i].m_y += y;
  67     }
  68     CalcBoundingBox();
  69 }
  70
  71 void wxCanvasPolyline::CalcBoundingBox()
  72 {
  73     m_bbox.SetValid(FALSE);
  74
  75     int i;
  76     for (i=0; i < m_n;i++)
  77     {
  78         m_bbox.Expand( m_points[i].m_x,m_points[i].m_y);
  79     }
  80
  81     //include the pen width also
  82     m_bbox.EnLarge(m_pen.GetWidth());
  83 }
  84
  85 void wxCanvasPolyline::Render(wxTransformMatrix* cworld, int clip_x, int clip_y, int clip_width, int clip_height )
  86 {
  87     if (!m_visible) return;
  88
  89     int start_y = clip_y;
  90     int end_y = clip_y+clip_height;
  91
  92     int start_x = clip_x;
  93     int end_x = clip_x+clip_width;
  94
  95 #if IMAGE_CANVAS
  96 #else
  97     wxPoint *cpoints = new wxPoint[m_n];
  98     int i;
  99     for (i = 0; i < m_n; i++)
 100     {
 101         double x1;
 102         double y1;
 103         //transform to absolute
 104         cworld->TransformPoint( m_points[i].m_x, m_points[i].m_y, x1, y1 );
 105         //transform to device
 106         cpoints[i].x = m_admin->LogicalToDeviceX(x1);
 107         cpoints[i].y = m_admin->LogicalToDeviceY(y1);
 108     }
 109     wxDC *dc = m_admin->GetActive()->GetDC();
 110     dc->SetClippingRegion(start_x,start_y,end_x-start_x,end_y-start_y);
 111     int pw=m_pen.GetWidth();
 112     m_pen.SetWidth(m_admin->LogicalToDeviceXRel(pw));
 113     dc->SetPen(m_pen);
 114     dc->DrawLines(m_n, cpoints, 0,0);
 115     delete [] cpoints;
 116     dc->SetPen(wxNullPen);
 117     dc->DestroyClippingRegion();
 118     m_pen.SetWidth(pw);
 119 #endif
 120 }
 121
 122 void wxCanvasPolyline::WriteSVG( wxTextOutputStream &stream )
 123 {
 124 }
 125
 126 wxCanvasObject* wxCanvasPolyline::IsHitWorld( double x, double y, double margin )
 127 {
 128     if ((x >= m_bbox.GetMinX()-margin) &&
 129         (x <= m_bbox.GetMaxX()+margin) &&
 130         (y >= m_bbox.GetMinY()-margin) &&
 131         (y <= m_bbox.GetMaxY()+margin)
 132        )
 133     {
 134         wxPoint2DDouble P=wxPoint2DDouble(x,y);
 135         if (PointOnPolyline(P,m_pen.GetWidth()/2+margin))
 136             return this;
 137         else
 138             return (wxCanvasObject*) NULL;
 139     }
 140     return (wxCanvasObject*) NULL;
 141 }
 142
 143 bool wxCanvasPolyline::PointOnPolyline(const wxPoint2DDouble& P, double margin)
 144 {
 145     bool    result = FALSE;
 146     double  distance;
 147     wxPoint2DDouble p1,p2;
 148
 149     p2=m_points[0];
 150     int i;
 151     for (i = 0; i < m_n-1; i++)
 152     {
 153         p1=p2;
 154         p2=m_points[i+1];
 155         if (margin > sqrt(pow(p1.m_x-P.m_x,2)+pow(p1.m_y-P.m_y,2)))
 156         {
 157             result=TRUE;
 158             break;
 159         }
 160         else if (!((p1.m_x == p2.m_x) && (p1.m_y == p2.m_y)))
 161         {
 162             wxLine line1(p1,p2);
 163             if (line1.PointInLine(P,distance,margin) == R_IN_AREA)
 164             {
 165                 result=TRUE;
 166                 break;
 167             }
 168         }
 169     }
 170
 171     return result;
 172 }
 173
 174 //----------------------------------------------------------------------------
 175 // wxCanvasPolygon
 176 //----------------------------------------------------------------------------
 177
 178 wxCanvasPolygon::wxCanvasPolygon( int n, wxPoint2DDouble points[],bool splined)
 179    : wxCanvasObject()
 180 {
 181     m_n = n;
 182     m_points = points;
 183     m_brush = *wxBLACK_BRUSH;
 184     m_pen = *wxTRANSPARENT_PEN;
 185     m_textfg=*wxBLACK;
 186     m_textbg=*wxWHITE;
 187     m_transp=FALSE;
 188     m_gpen=*wxBLACK_PEN;
 189     m_gdistance=0;
 190     m_gradient=FALSE;
 191     m_spline = splined;
 192
 193     if (m_spline)
 194     {
 195         ConvertSplinedPolygon(m_n, &m_points, 10 );
 196     }
 197
 198     CalcBoundingBox();
 199 }
 200
 201 wxCanvasPolygon::~wxCanvasPolygon()
 202 {
 203     delete m_points;
 204 }
 205
 206 void wxCanvasPolygon::SetPosXY( double x, double y)
 207 {
 208     double xo=m_points[0].m_x;
 209     double yo=m_points[0].m_y;
 210     int i;
 211     for (i=0; i < m_n;i++)
 212     {
 213         m_points[i].m_x += (x-xo);
 214         m_points[i].m_y += (y-yo);
 215     }
 216     CalcBoundingBox();
 217 }
 218
 219 void wxCanvasPolygon::TransLate( double x, double y )
 220 {
 221     int i;
 222     for (i=0; i < m_n;i++)
 223     {
 224         m_points[i].m_x += x;
 225         m_points[i].m_y += y;
 226     }
 227     CalcBoundingBox();
 228 }
 229
 230 void wxCanvasPolygon::CalcBoundingBox()
 231 {
 232
 233     m_bbox.SetValid(FALSE);
 234
 235     int i;
 236     for (i=0; i < m_n;i++)
 237     {
 238         m_bbox.Expand( m_points[i].m_x,m_points[i].m_y);
 239     }
 240
 241     //include the pen width also
 242     m_bbox.EnLarge(m_pen.GetWidth());
 243 }
 244
 245 void wxCanvasPolygon::Render(wxTransformMatrix* cworld, int clip_x, int clip_y, int clip_width, int clip_height )
 246 {
 247     if (!m_visible) return;
 248
 249     int start_y = clip_y;
 250     int end_y = clip_y+clip_height;
 251
 252     int start_x = clip_x;
 253     int end_x = clip_x+clip_width;
 254
 255 #if IMAGE_CANVAS
 256 #else
 257     //one extra for drawlines in some cases
 258     wxPoint *cpoints = new wxPoint[m_n+1];
 259     int i;
 260     for (i = 0; i < m_n; i++)
 261     {
 262         double x1;
 263         double y1;
 264         cworld->TransformPoint( m_points[i].m_x, m_points[i].m_y, x1, y1 );
 265         cpoints[i].x = m_admin->LogicalToDeviceX(x1);
 266         cpoints[i].y = m_admin->LogicalToDeviceY(y1);
 267     }
 268     double x1;
 269     double y1;
 270     cworld->TransformPoint( m_points[0].m_x, m_points[0].m_y, x1, y1 );
 271     cpoints[m_n].x = m_admin->LogicalToDeviceX(x1);
 272     cpoints[m_n].y = m_admin->LogicalToDeviceY(y1);
 273
 274     wxDC *dc = m_admin->GetActive()->GetDC();
 275     dc->SetClippingRegion(start_x,start_y,end_x-start_x,end_y-start_y);
 276     dc->SetBrush(m_brush);
 277     int pw=m_pen.GetWidth();
 278     m_pen.SetWidth(m_admin->LogicalToDeviceXRel(pw));
 279     if ( m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE && m_transp)
 280     {
 281         //draw a transparent polygon
 282         //leaf the pen not transparent, which i prefer
 283         dc->SetPen( wxPen( *wxWHITE,m_admin->LogicalToDeviceXRel(pw), wxSOLID) );
 284         dc->SetTextForeground(*wxBLACK);
 285         dc->SetTextBackground(*wxWHITE);
 286         dc->SetLogicalFunction(wxAND_INVERT);
 287         // BLACK OUT the opaque pixels and leave the rest as is
 288         dc->DrawPolygon(m_n, cpoints, 0,0,wxWINDING_RULE);
 289         // Set background and foreground colors for fill pattern
 290         //the previous blacked out pixels are now merged with the layer color
 291         //while the non blacked out pixels stay as they are.
 292         dc->SetTextForeground(*wxBLACK);
 293         //now define what will be the color of the fillpattern parts that are not transparent
 294         dc->SetTextBackground(m_textfg);
 295         dc->SetLogicalFunction(wxOR);
 296         //don't understand how but the outline is also depending on logicalfunction
 297         dc->SetPen(m_pen);
 298         dc->DrawPolygon(m_n, cpoints, 0,0,wxWINDING_RULE);
 299     }
 300     else if (m_gradient)
 301     {
 302         int pw2=m_gpen.GetWidth();
 303         m_gpen.SetWidth(m_admin->LogicalToDeviceYRel(pw2));
 304         FillPolygon(cworld,clip_x,clip_y,clip_width,clip_height );
 305         if (m_pen.GetStyle() != wxTRANSPARENT)
 306         {
 307             dc->SetPen(m_pen);
 308             dc->DrawLines(m_n+1, cpoints, 0,0);
 309         }
 310         m_gpen.SetWidth(pw2);
 311     }
 312     else
 313     {
 314         dc->SetPen(m_pen);
 315         dc->DrawPolygon(m_n, cpoints, 0,0,wxWINDING_RULE);
 316     }
 317     delete [] cpoints;
 318     dc->SetBrush(wxNullBrush);
 319     dc->SetPen(wxNullPen);
 320     dc->DestroyClippingRegion();
 321     m_pen.SetWidth(pw);
 322 #endif
 323 }
 324
 325 void wxCanvasPolygon::WriteSVG( wxTextOutputStream &stream )
 326 {
 327 }
 328
 329 wxCanvasObject* wxCanvasPolygon::IsHitWorld( double x, double y, double margin )
 330 {
 331     if ((x >= m_bbox.GetMinX()-margin) &&
 332         (x <= m_bbox.GetMaxX()+margin) &&
 333         (y >= m_bbox.GetMinY()-margin) &&
 334         (y <= m_bbox.GetMaxY()+margin)
 335        )
 336     {
 337         wxPoint2DDouble P=wxPoint2DDouble(x,y);
 338         INOUTPOLY io=PointInPolygon(P, m_pen.GetWidth()/2+margin);
 339         if (io == OUTSIDE_POLY)
 340             return (wxCanvasObject*) NULL;
 341         else
 342             return this;
 343     }
 344     return (wxCanvasObject*) NULL;
 345 }
 346
 347 INOUTPOLY wxCanvasPolygon::PointInPolygon(const wxPoint2DDouble& P, double marge)
 348 {
 349     int     R_tot = 0, L_tot = 0;
 350     int     p1_LRO, p2_LRO;
 351     double  px = P.m_x, py = P.m_y;
 352     double  Y_intersect;
 353     wxPoint2DDouble p1,p2;
 354
 355     //iterate across points until we are sure that the given point is in or out
 356     int i;
 357     for (i = 0; i < m_n; i++)
 358     {
 359         p1 = m_points[i];
 360         if (i == m_n-1)
 361             p2 = m_points[0];
 362         else
 363             p2 = m_points[i+1];
 364
 365         //more accurate
 366         GetLRO(P,p1,p2,p1_LRO,p2_LRO,marge/10);
 367         if (p1_LRO != p2_LRO)
 368         {
 369             int L = 0, R = 0;
 370             if (p2_LRO == -1) { R = -p1_LRO; L = 1; }
 371             if (p2_LRO == 0) if (p1_LRO == 1) R = -1; else L = -1;
 372             if (p2_LRO == 1) { R = 1; L = p1_LRO; }
 373
 374             // calculate intersection point with line for px
 375             if (p1_LRO == 0)
 376             {
 377                 if ((p1.m_y < (py + marge)) && (p1.m_y > (py - marge)))
 378                     return ON_POLY;
 379                 else
 380                     Y_intersect = p1.m_y;
 381             }
 382             else if (p2_LRO == 0)
 383             {
 384                 if ((p2.m_y < (py + marge)) && (p2.m_y > (py - marge)))
 385                     return ON_POLY;
 386                 else
 387                     Y_intersect = p2.m_y;
 388             }
 389             else //both p2_LRO and p1_LRO not 0
 390             {
 391                 if ((p1.m_y > (py + marge)) && (p2.m_y > (py + marge)))
 392                     Y_intersect = p1.m_y; //a save value to check later
 393                 else if ((p1.m_y < (py- marge)) && (p2.m_y < (py - marge)))
 394                     Y_intersect = p1.m_y; //a save value to check later
 395                 else //need to calculate intersection
 396                 {
 397                     if (!((p1.m_x == p2.m_x) && (p1.m_y == p2.m_y)))
 398                     {
 399                         wxLine line1(p1,p2);
 400                         line1.CalculateLineParameters();
 401                         Y_intersect = line1.Calculate_Y(px);
 402                     }
 403                     else
 404                          continue;
 405                 }
 406             }
 407             if (Y_intersect > (py + marge))
 408             {
 409                 R_tot += R;
 410                 L_tot += L;
 411             }
 412             else if ((Y_intersect <= (py + marge)) && (Y_intersect >= (py - marge)))
 413             {
 414                return ON_POLY;
 415             }
 416         }
 417     }
 418
 419     // geef het juiste resultaat terug
 420     if (R_tot == 0)
 421         if (L_tot == 0) return OUTSIDE_POLY;
 422         else return ON_POLY;
 423     else
 424         if (L_tot == 0) return ON_POLY;
 425         else return INSIDE_POLY;
 426 }
 427
 428 //----------------------------------------------------------------------------
 429 // wxCanvasPolylineL
 430 //----------------------------------------------------------------------------
 431
 432 wxCanvasPolylineL::wxCanvasPolylineL( wxList* points, bool spline )
 433    : wxCanvasObject()
 434 {
 435     m_lpoints = points;
 436     m_pen = *wxBLACK_PEN;
 437     m_spline=spline;
 438     if (m_spline)
 439         ConvertSplinedPolyline(m_lpoints, 10);
 440     CalcBoundingBox();
 441 }
 442
 443 wxCanvasPolylineL::~wxCanvasPolylineL()
 444 {
 445     m_lpoints->DeleteContents(TRUE);
 446     delete m_lpoints;
 447 }
 448
 449 double wxCanvasPolylineL::GetPosX()
 450 {
 451     wxNode *node = m_lpoints->GetFirst();
 452     wxPoint2DDouble* point = (wxPoint2DDouble*)node->Data();
 453     return point->m_x;
 454 }
 455
 456 double wxCanvasPolylineL::GetPosY()
 457 {
 458     wxNode *node = m_lpoints->GetFirst();
 459     wxPoint2DDouble* point = (wxPoint2DDouble*)node->Data();
 460     return point->m_y;
 461 }
 462
 463 void wxCanvasPolylineL::SetPosXY( double x, double y )
 464 {
 465     wxNode *node = m_lpoints->GetFirst();
 466     wxPoint2DDouble* point = (wxPoint2DDouble*)node->Data();
 467     double xo=point->m_x;
 468     double yo=point->m_y;
 469     while (node)
 470     {
 471         point = (wxPoint2DDouble*)node->Data();
 472         point->m_x = point->m_x + x-xo;
 473         point->m_y = point->m_y + y-yo;
 474         node = node->GetNext();
 475     }
 476     CalcBoundingBox();
 477 }
 478
 479 void wxCanvasPolylineL::TransLate( double x, double y )
 480 {
 481     wxNode *node = m_lpoints->GetFirst();
 482     while (node)
 483     {
 484         wxPoint2DDouble* point = (wxPoint2DDouble*)node->Data();
 485         point->m_x += x;
 486         point->m_y += y;
 487         node = node->GetNext();
 488     }
 489     CalcBoundingBox();
 490 }
 491
 492 void wxCanvasPolylineL::CalcBoundingBox()
 493 {
 494     m_bbox.SetValid(FALSE);
 495
 496     wxNode *node = m_lpoints->GetFirst();
 497     while (node)
 498     {
 499         wxPoint2DDouble* point = (wxPoint2DDouble*)node->Data();
 500         m_bbox.Expand( point->m_x,point->m_y);
 501         node = node->GetNext();
 502     }
 503
 504     //include the pen width also
 505     m_bbox.EnLarge(m_pen.GetWidth());
 506 }
 507
 508 void wxCanvasPolylineL::Render(wxTransformMatrix* cworld, int clip_x, int clip_y, int clip_width, int clip_height )
 509 {
 510     if (!m_visible) return;
 511
 512     int start_y = clip_y;
 513     int end_y = clip_y+clip_height;
 514
 515     int start_x = clip_x;
 516     int end_x = clip_x+clip_width;
 517
 518 #if IMAGE_CANVAS
 519 #else
 520     int n=m_lpoints->GetCount();
 521     wxPoint *cpoints = new wxPoint[n];
 522
 523     wxNode *node = m_lpoints->GetFirst();
 524     int i=0;
 525     while (node)
 526     {
 527         wxPoint2DDouble* point = (wxPoint2DDouble*)node->Data();
 528         double x1;
 529         double y1;
 530         //transform to absolute
 531         cworld->TransformPoint( point->m_x, point->m_y, x1, y1 );
 532         //transform to device
 533         cpoints[i].x = m_admin->LogicalToDeviceX(x1);
 534         cpoints[i].y = m_admin->LogicalToDeviceY(y1);
 535
 536         node = node->GetNext();
 537         i++;
 538     }
 539
 540     wxDC *dc = m_admin->GetActive()->GetDC();
 541     dc->SetClippingRegion(start_x,start_y,end_x-start_x,end_y-start_y);
 542     int pw=m_pen.GetWidth();
 543     m_pen.SetWidth(m_admin->LogicalToDeviceXRel(pw));
 544     dc->SetPen(m_pen);
 545     dc->DrawLines(n, cpoints, 0,0);
 546     delete [] cpoints;
 547     dc->SetPen(wxNullPen);
 548     dc->DestroyClippingRegion();
 549     m_pen.SetWidth(pw);
 550 #endif
 551 }
 552
 553 void wxCanvasPolylineL::WriteSVG( wxTextOutputStream &stream )
 554 {
 555 }
 556
 557 wxCanvasObject* wxCanvasPolylineL::IsHitWorld( double x, double y, double margin )
 558 {
 559     if ((x >= m_bbox.GetMinX()-margin) &&
 560         (x <= m_bbox.GetMaxX()+margin) &&
 561         (y >= m_bbox.GetMinY()-margin) &&
 562         (y <= m_bbox.GetMaxY()+margin)
 563        )
 564     {
 565         wxPoint2DDouble P=wxPoint2DDouble(x,y);
 566         if (PointOnPolyline(P,m_pen.GetWidth()/2+margin))
 567             return this;
 568         else
 569             return (wxCanvasObject*) NULL;
 570     }
 571     return (wxCanvasObject*) NULL;
 572 }
 573
 574 bool wxCanvasPolylineL::PointOnPolyline(const wxPoint2DDouble& P, double margin)
 575 {
 576     bool    result = FALSE;
 577     double  distance;
 578     wxPoint2DDouble p1,p2;
 579
 580     wxNode *node = m_lpoints->GetFirst();
 581     p2 = *(wxPoint2DDouble*)node->Data();
 582     while (node && !result)
 583     {
 584         p1=p2;
 585         node=node->GetNext();
 586         if (!node) break;
 587         p2 = *(wxPoint2DDouble*)node->Data();
 588
 589         if (margin > sqrt(pow(p1.m_x-P.m_x,2)+pow(p1.m_y-P.m_y,2)))
 590             result=TRUE;
 591         else if (!((p1.m_x == p2.m_x) && (p1.m_y == p2.m_y)))
 592         {
 593             wxLine line1(p1,p2);
 594             if (line1.PointInLine(P,distance,margin) == R_IN_AREA)
 595             result=TRUE;
 596         }
 597     }
 598
 599     return result;
 600 }
 601
 602 //----------------------------------------------------------------------------
 603 // wxCanvasPolygon
 604 //----------------------------------------------------------------------------
 605
 606 wxCanvasPolygonL::wxCanvasPolygonL( wxList* points, bool spline )
 607    : wxCanvasObject()
 608 {
 609     m_lpoints = points;
 610     m_brush = *wxBLACK_BRUSH;
 611     m_pen = *wxTRANSPARENT_PEN;
 612     m_spline=spline;
 613     m_textfg=*wxBLACK;
 614     m_textbg=*wxWHITE;
 615     m_transp=FALSE;
 616
 617     if (m_spline)
 618         ConvertSplinedPolyline(m_lpoints, 10);
 619     CalcBoundingBox();
 620 }
 621
 622 wxCanvasPolygonL::~wxCanvasPolygonL()
 623 {
 624     m_lpoints->DeleteContents(TRUE);
 625     delete m_lpoints;
 626 }
 627
 628 double wxCanvasPolygonL::GetPosX()
 629 {
 630     wxNode *node = m_lpoints->GetFirst();
 631     wxPoint2DDouble* point = (wxPoint2DDouble*)node->Data();
 632     return point->m_x;
 633 }
 634
 635 double wxCanvasPolygonL::GetPosY()
 636 {
 637     wxNode *node = m_lpoints->GetFirst();
 638     wxPoint2DDouble* point = (wxPoint2DDouble*)node->Data();
 639     return point->m_y;
 640 }
 641
 642 void wxCanvasPolygonL::SetPosXY( double x, double y )
 643 {
 644     wxNode *node = m_lpoints->GetFirst();
 645     wxPoint2DDouble* point = (wxPoint2DDouble*)node->Data();
 646     double xo=point->m_x;
 647     double yo=point->m_y;
 648     while (node)
 649     {
 650         point = (wxPoint2DDouble*)node->Data();
 651         point->m_x = point->m_x + x-xo;
 652         point->m_y = point->m_y + y-yo;
 653         node = node->GetNext();
 654     }
 655     CalcBoundingBox();
 656 }
 657
 658 void wxCanvasPolygonL::TransLate( double x, double y )
 659 {
 660     wxNode *node = m_lpoints->GetFirst();
 661     while (node)
 662     {
 663         wxPoint2DDouble* point = (wxPoint2DDouble*)node->Data();
 664         point->m_x += x;
 665         point->m_y += y;
 666         node = node->GetNext();
 667     }
 668     CalcBoundingBox();
 669 }
 670
 671 void wxCanvasPolygonL::CalcBoundingBox()
 672 {
 673
 674     m_bbox.SetValid(FALSE);
 675
 676     wxNode *node = m_lpoints->GetFirst();
 677     while (node)
 678     {
 679         wxPoint2DDouble* point = (wxPoint2DDouble*)node->Data();
 680         m_bbox.Expand( point->m_x,point->m_y);
 681         node = node->GetNext();
 682     }
 683
 684     //include the pen width also
 685     m_bbox.EnLarge(m_pen.GetWidth());
 686 }
 687
 688 void wxCanvasPolygonL::Render(wxTransformMatrix* cworld, int clip_x, int clip_y, int clip_width, int clip_height )
 689 {
 690     if (!m_visible) return;
 691
 692     int start_y = clip_y;
 693     int end_y = clip_y+clip_height;
 694
 695     int start_x = clip_x;
 696     int end_x = clip_x+clip_width;
 697
 698 #if IMAGE_CANVAS
 699 #else
 700     int n=m_lpoints->GetCount();
 701     wxPoint *cpoints = new wxPoint[n];
 702
 703     wxNode *node = m_lpoints->GetFirst();
 704     int i=0;
 705     while (node)
 706     {
 707         wxPoint2DDouble* point = (wxPoint2DDouble*)node->Data();
 708         double x1;
 709         double y1;
 710         //transform to absolute
 711         cworld->TransformPoint( point->m_x, point->m_y, x1, y1 );
 712         //transform to device
 713         cpoints[i].x = m_admin->LogicalToDeviceX(x1);
 714         cpoints[i].y = m_admin->LogicalToDeviceY(y1);
 715
 716         node = node->GetNext();
 717         i++;
 718     }
 719     wxDC *dc = m_admin->GetActive()->GetDC();
 720     dc->SetClippingRegion(start_x,start_y,end_x-start_x,end_y-start_y);
 721     dc->SetBrush(m_brush);
 722     int pw=m_pen.GetWidth();
 723     m_pen.SetWidth(m_admin->LogicalToDeviceXRel(pw));
 724     if ( m_brush.GetStyle() == wxSTIPPLE_MASK_OPAQUE && m_transp)
 725     {
 726         //draw a transparent polygon
 727         //leaf the pen not transparent, which i prefer
 728         dc->SetPen( wxPen( *wxWHITE,m_admin->LogicalToDeviceXRel(pw), wxSOLID) );
 729         dc->SetTextForeground(*wxBLACK);
 730         dc->SetTextBackground(*wxWHITE);
 731         dc->SetLogicalFunction(wxAND_INVERT);
 732         // BLACK OUT the opaque pixels and leave the rest as is
 733         dc->DrawPolygon(n, cpoints, 0,0,wxWINDING_RULE);
 734         // Set background and foreground colors for fill pattern
 735         //the previous blacked out pixels are now merged with the layer color
 736         //while the non blacked out pixels stay as they are.
 737         dc->SetTextForeground(*wxBLACK);
 738         //now define what will be the color of the fillpattern parts that are not transparent
 739         dc->SetTextBackground(m_textfg);
 740         dc->SetLogicalFunction(wxOR);
 741         //don't understand how but the outline is also depending on logicalfunction
 742         dc->SetPen(m_pen);
 743         dc->DrawPolygon(n, cpoints, 0,0,wxWINDING_RULE);
 744         dc->SetLogicalFunction(wxCOPY);
 745     }
 746     else
 747     {
 748         dc->SetPen(m_pen);
 749         dc->SetTextForeground(m_textfg);
 750         dc->SetTextBackground(m_textbg);
 751         dc->DrawPolygon(n, cpoints, 0,0,wxWINDING_RULE);
 752     }
 753     delete [] cpoints;
 754     dc->SetBrush(wxNullBrush);
 755     dc->SetPen(wxNullPen);
 756     dc->DestroyClippingRegion();
 757     m_pen.SetWidth(pw);
 758 #endif
 759 }
 760
 761 void wxCanvasPolygonL::WriteSVG( wxTextOutputStream &stream )
 762 {
 763 }
 764
 765 static void GetLRO(const wxPoint2DDouble& P, const wxPoint2DDouble& p1, const wxPoint2DDouble& p2, int &LRO1, int &LRO2,const double marge)
 766 {
 767     if (p1.m_x > (P.m_x + marge)) LRO1 = -1;        // beginnode is right of P
 768     else
 769         if (p1.m_x < (P.m_x - marge)) LRO1 = 1;     // beginnode is left of P
 770         else LRO1 = 0;                              // beginnode is on vertical line through P
 771
 772     if (p2.m_x > (P.m_x + marge)) LRO2 = -1;        // endnode is right of P
 773     else
 774         if (p2.m_x < (P.m_x - marge)) LRO2 = 1;     // endnode is left of P
 775         else LRO2 = 0;                              // endnode is on vertical line through P
 776 }
 777
 778 wxCanvasObject* wxCanvasPolygonL::IsHitWorld( double x, double y, double margin )
 779 {
 780     if ((x >= m_bbox.GetMinX()-margin) &&
 781         (x <= m_bbox.GetMaxX()+margin) &&
 782         (y >= m_bbox.GetMinY()-margin) &&
 783         (y <= m_bbox.GetMaxY()+margin)
 784        )
 785     {
 786         wxPoint2DDouble P=wxPoint2DDouble(x,y);
 787         INOUTPOLY io=PointInPolygon(P,m_pen.GetWidth()/2 + margin);
 788         if (io == OUTSIDE_POLY)
 789             return (wxCanvasObject*) NULL;
 790         else
 791             return this;
 792     }
 793     return (wxCanvasObject*) NULL;
 794 }
 795
 796 INOUTPOLY wxCanvasPolygonL::PointInPolygon(const wxPoint2DDouble& P, double marge)
 797 {
 798     int     R_tot = 0, L_tot = 0;
 799     int     p1_LRO, p2_LRO;
 800     double  px = P.m_x, py = P.m_y;
 801     double  Y_intersect;
 802     wxPoint2DDouble p1,p2;
 803
 804     //iterate across points until we are sure that the given point is in or out
 805     wxNode *node = m_lpoints->GetFirst();
 806
 807     while (node)
 808     {
 809         p1 = *(wxPoint2DDouble*)node->Data();
 810         if (m_lpoints->GetLast() == node)
 811         {
 812             p2 = *(wxPoint2DDouble*)m_lpoints->GetFirst();
 813         }
 814         else
 815         {
 816             p2 = *(wxPoint2DDouble*)node->GetNext()->Data();
 817         }
 818
 819         //more accurate
 820         GetLRO(P,p1,p2,p1_LRO,p2_LRO,marge/10);
 821         if (p1_LRO != p2_LRO)
 822         {
 823             int L = 0, R = 0;
 824             if (p2_LRO == -1) { R = -p1_LRO; L = 1; }
 825             if (p2_LRO == 0) if (p1_LRO == 1) R = -1; else L = -1;
 826             if (p2_LRO == 1) { R = 1; L = p1_LRO; }
 827
 828             // calculate intersection point with line for px
 829             if (p1_LRO == 0)
 830             {
 831                 if ((p1.m_y < (py + marge)) && (p1.m_y > (py - marge)))
 832                     return ON_POLY;
 833                 else
 834                     Y_intersect = p1.m_y;
 835             }
 836             else if (p2_LRO == 0)
 837             {
 838                 if ((p2.m_y < (py + marge)) && (p2.m_y > (py - marge)))
 839                     return ON_POLY;
 840                 else
 841                     Y_intersect = p2.m_y;
 842             }
 843             else //both p2_LRO and p1_LRO not 0
 844             {
 845                 if ((p1.m_y > (py + marge)) && (p2.m_y > (py + marge)))
 846                     Y_intersect = p1.m_y; //a save value to check later
 847                 else if ((p1.m_y < (py- marge)) && (p2.m_y < (py - marge)))
 848                     Y_intersect = p1.m_y; //a save value to check later
 849                 else //need to calculate intersection
 850                 {
 851                     if (!((p1.m_x == p2.m_x) && (p1.m_y == p2.m_y)))
 852                     {
 853                         wxLine line1(p1,p2);
 854                         line1.CalculateLineParameters();
 855                         Y_intersect = line1.Calculate_Y(px);
 856                     }
 857                     else
 858                          continue;
 859                 }
 860             }
 861             if (Y_intersect > (py + marge))
 862             {
 863                 R_tot += R;
 864                 L_tot += L;
 865             }
 866             else if ((Y_intersect <= (py + marge)) && (Y_intersect >= (py - marge)))
 867             {
 868                return ON_POLY;
 869             }
 870         }
 871         node=node->Next();
 872     }
 873
 874     // geef het juiste resultaat terug
 875     if (R_tot == 0)
 876         if (L_tot == 0) return OUTSIDE_POLY;
 877         else return ON_POLY;
 878     else
 879         if (L_tot == 0) return ON_POLY;
 880         else return INSIDE_POLY;
 881 }
 882
 883 // ---------------------------------------------------------------------------
 884 // spline drawing code
 885 // ---------------------------------------------------------------------------
 886
 887 static void gds_quadratic_spline(wxList *org,double a1, double b1, double a2, double b2,
 888                          double a3, double b3, double a4, double b4,double aber);
 889 static void gds_clear_stack();
 890 static int gds_spline_pop(double *x1, double *y1, double *x2, double *y2, double *x3,
 891                   double *y3, double *x4, double *y4);
 892 static void gds_spline_push(double x1, double y1, double x2, double y2, double x3, double y3,
 893                     double x4, double y4);
 894
 895 void ConvertSplinedPolygon(int& n, wxPoint2DDouble* points[], double Aber)
 896 {
 897     wxList h;
 898     int i;
 899     for (i = 0; i < n; i++)
 900     {
 901         h.Append((wxObject*) new wxPoint2DDouble((*points)[i].m_x, (*points)[i].m_y));
 902     }
 903     delete *points;
 904
 905     ConvertSplinedPolygon(&h, Aber);
 906
 907     n=h.GetCount();
 908     *points = new wxPoint2DDouble[n];
 909     wxNode* node=h.GetFirst();
 910     for (i = 0; i < n; i++)
 911     {
 912         wxNode* hh= node;
 913         node = node->GetNext();
 914         (*points)[i].m_x=((wxPoint2DDouble*) hh->GetData())->m_x;
 915         (*points)[i].m_y=((wxPoint2DDouble*) hh->GetData())->m_y;
 916         delete (wxPoint2DDouble*) hh->GetData();
 917         h.DeleteNode(hh);
 918     }
 919 }
 920
 921 void ConvertSplinedPolygon(wxList* list, double Aber)
 922 {
 923     wxPoint2DDouble* point;
 924     double           cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
 925     double           x1, y1, x2, y2;
 926
 927     if (list->GetCount() <2)
 928         return;
 929
 930     wxNode* iter=list->GetLast();
 931     x1 = ((wxPoint2DDouble*)iter->Data())->m_x;
 932     y1 = ((wxPoint2DDouble*)iter->Data())->m_y;
 933
 934     iter=list->GetFirst();
 935     x2 = ((wxPoint2DDouble*)iter->Data())->m_x;
 936     y2 = ((wxPoint2DDouble*)iter->Data())->m_y;
 937
 938     point = new wxPoint2DDouble(x2,y2);
 939     list->Append((wxObject*)point);
 940
 941     cx1 = (x1 + x2) / 2.0;
 942     cy1 = (y1 + y2) / 2.0;
 943     cx2 = (cx1 + x2) / 2.0;
 944     cy2 = (cy1 + y2) / 2.0;
 945
 946     delete (wxPoint2DDouble*) iter->Data();
 947     delete iter;
 948     iter=list->GetFirst();
 949     x1 = ((wxPoint2DDouble*)iter->Data())->m_x;
 950     y1 = ((wxPoint2DDouble*)iter->Data())->m_y;
 951     point = new wxPoint2DDouble(x1,y1);
 952     list->Append((wxObject*)point);
 953
 954     int i=1;
 955     int count=list->GetCount();
 956     while (i < count)
 957     {
 958         x1 = x2;
 959         y1 = y2;
 960         x2 = ((wxPoint2DDouble*)iter->Data())->m_x;
 961         y2 = ((wxPoint2DDouble*)iter->Data())->m_y;
 962         cx4 = (x1 + x2) / 2.0;
 963         cy4 = (y1 + y2) / 2.0;
 964         cx3 = (x1 + cx4) / 2.0;
 965         cy3 = (y1 + cy4) / 2.0;
 966
 967         gds_quadratic_spline(list,cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4,Aber);
 968
 969         cx1 = cx4;
 970         cy1 = cy4;
 971         cx2 = (cx1 + x2) / 2.0;
 972         cy2 = (cy1 + y2) / 2.0;
 973         delete (wxPoint2DDouble*)iter->Data();
 974         delete iter;
 975         iter=list->GetFirst();
 976         i++;
 977     }
 978
 979     iter=list->GetFirst();
 980     delete (wxPoint2DDouble*)iter->Data();
 981     delete iter;
 982 }
 983
 984 void ConvertSplinedPolyline(wxList* list,double Aber)
 985 {
 986     double           cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4;
 987     double           x1, y1, x2, y2;
 988
 989
 990     if (list->GetCount() <2)
 991         return;
 992
 993
 994
 995     wxNode* iter=list->GetFirst();
 996
 997     x1 = ((wxPoint2DDouble*)iter->Data())->m_x;
 998     y1 = ((wxPoint2DDouble*)iter->Data())->m_y;
 999
1000     delete (wxPoint2DDouble*)iter->Data();
1001     delete iter;
1002     iter=list->GetFirst();
1003     x2 = ((wxPoint2DDouble*)iter->Data())->m_x;
1004     y2 = ((wxPoint2DDouble*)iter->Data())->m_y;
1005     cx1 = (x1 + x2) / 2.0;
1006     cy1 = (y1 + y2) / 2.0;
1007     cx2 = (cx1 + x2) / 2.0;
1008     cy2 = (cy1 + y2) / 2.0;
1009
1010     wxPoint2DDouble* point = new wxPoint2DDouble(x1,y1);
1011     list->Append((wxObject*)point);
1012
1013     delete (wxPoint2DDouble*)iter->Data();
1014     delete iter;
1015     iter=list->GetFirst();
1016
1017     int i=1;
1018     int count=list->GetCount();
1019     while (i < count)
1020     {
1021         x1 = x2;
1022         y1 = y2;
1023         x2 = ((wxPoint2DDouble*)iter->Data())->m_x;
1024         y2 = ((wxPoint2DDouble*)iter->Data())->m_y;
1025         cx4 = (x1 + x2) / 2.0;
1026         cy4 = (y1 + y2) / 2.0;
1027         cx3 = (x1 + cx4) / 2.0;
1028         cy3 = (y1 + cy4) / 2.0;
1029
1030         gds_quadratic_spline(list,cx1, cy1, cx2, cy2, cx3, cy3, cx4, cy4,Aber);
1031
1032         cx1 = cx4;
1033         cy1 = cy4;
1034         cx2 = (cx1 + x2) / 2.0;
1035         cy2 = (cy1 + y2) / 2.0;
1036         delete (wxPoint2DDouble*)iter->Data();
1037         delete iter;
1038         iter=list->GetFirst();
1039         i++;
1040     }
1041
1042     point = new wxPoint2DDouble(cx1,cy1);
1043     list->Append((wxObject*)point);
1044
1045     point = new wxPoint2DDouble(x2,y2);
1046     list->Append((wxObject*)point);
1047 }
1048
1049 /********************* CURVES FOR SPLINES *****************************
1050
1051   The following spline drawing routine is from
1052
1053     "An Algorithm for High-Speed Curve Generation"
1054     by George Merrill Chaikin,
1055     Computer Graphics and Image Processing, 3, Academic Press,
1056     1974, 346-349.
1057
1058       and
1059
1060         "On Chaikin's Algorithm" by R. F. Riesenfeld,
1061         Computer Graphics and Image Processing, 4, Academic Press,
1062         1975, 304-310.
1063
1064 ***********************************************************************/
1065
1066 #define     half(z1, z2)    ((z1+z2)/2.0)
1067 #define     THRESHOLD   5
1068
1069 /* iterative version */
1070
1071 void gds_quadratic_spline(wxList *org,double a1, double b1, double a2, double b2, double a3, double b3, double a4,
1072                          double b4,double Aber)
1073 {
1074     register double  xmid, ymid;
1075     double           x1, y1, x2, y2, x3, y3, x4, y4;
1076     wxPoint2DDouble* point;
1077
1078     gds_clear_stack();
1079     gds_spline_push(a1, b1, a2, b2, a3, b3, a4, b4);
1080
1081     while (gds_spline_pop(&x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4))
1082     {
1083         xmid = half(x2, x3);
1084         ymid = half(y2, y3);
1085         if (fabs(x1 - xmid) < Aber && fabs(y1 - ymid) < Aber &&
1086             fabs(xmid - x4) < Aber && fabs(ymid - y4) < Aber)
1087         {
1088             point = new wxPoint2DDouble(x1,y1);
1089             org->Append((wxObject*)point);
1090             point = new wxPoint2DDouble(xmid,ymid);
1091             org->Append((wxObject*)point);
1092         } else {
1093             gds_spline_push(xmid, ymid, half(xmid, x3), half(ymid, y3),
1094                 half(x3, x4), half(y3, y4), x4, y4);
1095             gds_spline_push(x1, y1, half(x1, x2), half(y1, y2),
1096                 half(x2, xmid), half(y2, ymid), xmid, ymid);
1097         }
1098     }
1099 }
1100
1101
1102 /* utilities used by spline drawing routines */
1103
1104
1105 typedef struct gds_spline_stack_struct {
1106     double           x1, y1, x2, y2, x3, y3, x4, y4;
1107 }
1108 Stack;
1109
1110 #define         SPLINE_STACK_DEPTH             20
1111 static Stack    gds_spline_stack[SPLINE_STACK_DEPTH];
1112 static Stack   *gds_stack_top;
1113 static int      gds_stack_count;
1114
1115 static void gds_clear_stack()
1116 {
1117     gds_stack_top = gds_spline_stack;
1118     gds_stack_count = 0;
1119 }
1120
1121 static void gds_spline_push(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4)
1122 {
1123     gds_stack_top->x1 = x1;
1124     gds_stack_top->y1 = y1;
1125     gds_stack_top->x2 = x2;
1126     gds_stack_top->y2 = y2;
1127     gds_stack_top->x3 = x3;
1128     gds_stack_top->y3 = y3;
1129     gds_stack_top->x4 = x4;
1130     gds_stack_top->y4 = y4;
1131     gds_stack_top++;
1132     gds_stack_count++;
1133 }
1134
1135 int gds_spline_pop(double *x1, double *y1, double *x2, double *y2,
1136                   double *x3, double *y3, double *x4, double *y4)
1137 {
1138     if (gds_stack_count == 0)
1139         return (0);
1140     gds_stack_top--;
1141     gds_stack_count--;
1142     *x1 = gds_stack_top->x1;
1143     *y1 = gds_stack_top->y1;
1144     *x2 = gds_stack_top->x2;
1145     *y2 = gds_stack_top->y2;
1146     *x3 = gds_stack_top->x3;
1147     *y3 = gds_stack_top->y3;
1148     *x4 = gds_stack_top->x4;
1149     *y4 = gds_stack_top->y4;
1150     return (1);
1151 }
1152
1153 void wxAET::CalculateLineParameters( const wxPoint2DDouble& p1 , const wxPoint2DDouble& p2 )
1154 {
1155     double A = p2.m_y - p1.m_y; //A (y2-y1)
1156     if (A == 0)
1157     {
1158         m_horizontal=TRUE;
1159         m_BdivA=0;
1160         m_CdivA=0;
1161     }
1162     else
1163     {
1164         m_horizontal=FALSE;
1165         m_BdivA= (p1.m_x - p2.m_x)/A; //B (x1-x2)
1166         //normalize
1167         m_CdivA= ((p2.m_x*p1.m_y) - (p1.m_x*p2.m_y)) /A ;
1168     }
1169 }
1170
1171 void wxAET::CalculateXs( double y )
1172 {
1173     m_xs= -m_BdivA * y - m_CdivA;
1174 }
1175
1176 //use by polygon filling
1177 //moves the scanline up
1178 //index is the index of the point where the search begins
1179 //direction is +1 or -1 and indicates if the segment ascends or decends
1180 bool wxCanvasPolygon::MoveUp( double horline, int& index, int direction)
1181 {
1182     int walk = (index + direction + m_n) % m_n;
1183     while ( m_points[walk].m_y < horline )
1184     {
1185         if (m_points[walk].m_y < m_points[index].m_y )
1186             return FALSE;
1187         else
1188         {
1189             //modify index
1190             index=walk;
1191             walk = (index + direction + m_n) % m_n;
1192         }
1193     }
1194     return TRUE;
1195 }
1196
1197 //a crictical point is a point between a decending and a ascending segment
1198 //collect those points for filling later
1199 void wxCanvasPolygon::DetectCriticalPoints()
1200 {
1201     //candidate for critical point
1202     //true if Y is getting lower, unchanged i Y is unchanged
1203     //and if Y becomes higher and candidate was true: it is a critical point
1204     bool candidate = FALSE;
1205     int i,j;
1206
1207     for ( i=0; i < m_n; i++)
1208     {
1209         //j next point
1210         j= (i+1) % m_n;
1211
1212         //check if Y is smaller
1213         if (m_points[i].m_y > m_points[j].m_y)
1214             //we have a candidate
1215             candidate=TRUE;
1216         else if ( (m_points[i].m_y < m_points[j].m_y) && candidate)
1217         {   //this is a critical point put in list
1218             bool inserted=FALSE;
1219             wxNode *node = m_CRlist.GetFirst();
1220             while (node)
1221             {
1222                 //sorted on smallest Y value
1223                 int* ind=(int*) node->GetData();
1224                 if (m_points[*ind].m_y > m_points[i].m_y)
1225                 {
1226                     m_CRlist.Insert(node,(wxObject*) new int(i));
1227                     inserted = TRUE;
1228                     break;
1229                 }
1230                 node = node->GetNext();
1231             }
1232             if (!inserted)
1233                 m_CRlist.Append((wxObject*) new int(i));
1234             candidate = FALSE;
1235         }
1236     }
1237     if (candidate)
1238     {
1239         for ( i=0; i < m_n; i++)
1240         {
1241             //j next point
1242             j= (i+1) % m_n;
1243
1244             //check if Y is smaller
1245             if (m_points[i].m_y > m_points[j].m_y)
1246                 //we have a candidate
1247                 candidate=TRUE;
1248             else if ( (m_points[i].m_y < m_points[j].m_y) && candidate)
1249             {   //this is a critical point put in list
1250                 bool inserted=FALSE;
1251                 wxNode *node = m_CRlist.GetFirst();
1252                 while (node)
1253                 {
1254                     //sorted on smallest Y value
1255                     int* ind=(int*) node->GetData();
1256                     if (m_points[*ind].m_y > m_points[i].m_y)
1257                     {
1258                         m_CRlist.Insert(node,(wxObject*) new int(i));
1259                         inserted = TRUE;
1260                         break;
1261                     }
1262                     node = node->GetNext();
1263                 }
1264                 if (!inserted)
1265                     m_CRlist.Append((wxObject*) new int(i));
1266                 candidate = FALSE;
1267             }
1268         }
1269     }
1270 }
1271
1272
1273 void wxCanvasPolygon::FillPolygon(wxTransformMatrix* cworld, int clip_x, int clip_y, int clip_width, int clip_height )
1274 {
1275 #if IMAGE_CANVAS
1276 #else
1277     int index;
1278     //how much is on pixel in world coordinates
1279
1280     double scalefactor;
1281     if (m_gdistance)
1282         scalefactor=m_gdistance;
1283     else
1284         //abs here needed if yaxis is going up (always scan in world coordinates UP)
1285         scalefactor=fabs(m_admin->DeviceToLogicalYRel(1)); //1 pixel height
1286
1287     wxDC *dc = m_admin->GetActive()->GetDC();
1288     dc->SetClippingRegion( clip_x, clip_y, clip_width, clip_height );
1289     wxPen  gradientpen=m_gpen;
1290
1291     int dred = m_textbg.Red()-m_textfg.Red();
1292     int dgreen = m_textbg.Green()-m_textfg.Green();
1293     int dblue = m_textbg.Blue()-m_textfg.Blue();
1294
1295     //total number of lines to go from m_textbg to m_textfg
1296     //gives the following number of steps for the gradient color
1297     int stepcol = (int) (m_bbox.GetHeight()/scalefactor);
1298
1299     DetectCriticalPoints();
1300
1301     double min;
1302     double max;
1303     if (cworld->IsIdentity())
1304     {
1305         //TODO do something with clipping region (inverse transform?)
1306         //the next does not work, i don't know why
1307         //min = wxMin (m_admin->DeviceToLogicalY(clip_y),m_admin->DeviceToLogicalY(clip_y+clip_height));
1308         //max = wxMax (m_admin->DeviceToLogicalY(clip_y),m_admin->DeviceToLogicalY(clip_y+clip_height));
1309         min= m_bbox.GetMinY();
1310         max= m_bbox.GetMaxY();
1311     }
1312     else
1313     {
1314         min= m_bbox.GetMinY();
1315         max= m_bbox.GetMaxY();
1316     }
1317
1318     int curcol = (int)( (min - m_bbox.GetMinY())/scalefactor );
1319
1320     double i;
1321     for ( i = min; i < max; i+=scalefactor)
1322     {
1323         wxNode *node = m_AETlist.GetFirst();
1324         int count= m_AETlist.GetCount();
1325         while (count > 0)
1326         {
1327             wxAET* ele = ((wxAET*)node->GetData());
1328             index= ele->m_index;
1329             int direction = ele->m_direction;
1330             if (!MoveUp(i,index,direction))
1331             {
1332                 wxNode* h = node;
1333                 //remove this node
1334                 node = node->GetNext();
1335                 m_AETlist.DeleteNode(h);
1336             }
1337             else
1338             {
1339                 if (ele->m_index != index)
1340                 {
1341                    ele->m_index=index;
1342                    int h = (index + direction + m_n) % m_n;
1343                    ele->CalculateLineParameters(m_points[h],m_points[index]);
1344                 }
1345                 if (ele->m_horizontal)
1346                    ele->m_xs=m_points[index].m_x;
1347                 else
1348                    ele->CalculateXs(i);
1349                 node = node->GetNext();
1350             }
1351             count--;
1352         }
1353
1354         node = m_CRlist.GetFirst();
1355         while (m_CRlist.GetCount() && m_points[*((int*)node->GetData())].m_y <=i )
1356         {
1357             int DI;
1358             for ( DI = -1; DI <=1 ; DI+=2)
1359             {
1360                 index=*((int*)node->GetData());
1361                 if (MoveUp(i,index,DI))
1362                 {
1363                     wxAET* ele = new wxAET();
1364                     ele->m_index=index;
1365                     ele->m_direction=DI;
1366                     int h = (index + DI + m_n) % m_n;
1367                     ele->CalculateLineParameters(m_points[h],m_points[index]);
1368                     if (ele->m_horizontal)
1369                         ele->m_xs=m_points[index].m_x;
1370                     else
1371                         ele->CalculateXs(i);
1372
1373                     //insert in sorted order od m_xs
1374                     bool inserted=FALSE;
1375                     wxNode *node2 = m_AETlist.GetFirst();
1376                     while (node2)
1377                     {
1378                         //sorted on smallest xs value
1379                         if (ele->m_xs < ((wxAET*)node2->GetData())->m_xs)
1380                         {
1381                             m_AETlist.Insert(node2,(wxObject*) ele);
1382                             inserted = TRUE;
1383                             break;
1384                         }
1385                         node2 = node2->GetNext();
1386                     }
1387                     if (!inserted)
1388                         m_AETlist.Append((wxObject*)ele);
1389                 }
1390             }
1391
1392             wxNode* h= node;
1393             node = node->GetNext();
1394             m_CRlist.DeleteNode(h);
1395         }
1396
1397         curcol++;
1398         wxColour gradcol(m_textbg.Red()+dred*curcol/stepcol,
1399                          m_textbg.Green()+dgreen*curcol/stepcol,
1400                          m_textbg.Blue()+dblue*curcol/stepcol);
1401         gradientpen.SetColour(gradcol);
1402
1403         //m_AETlist must be sorted in m_xs at this moment
1404         //now draw all the line parts on one horizontal scanline (Winding Rule)
1405         int out= 0;
1406         node = m_AETlist.GetFirst();
1407         while (node)
1408         {
1409             wxAET* ele = ((wxAET*)node->GetData());
1410             out+=ele->m_direction;
1411             if (out != 0)
1412             {
1413                 double x1=ele->m_xs;
1414                 node = node->GetNext();
1415                 ele = ((wxAET*)node->GetData());
1416                 double x2=ele->m_xs;
1417                 dc->SetPen( gradientpen );
1418                 double wx1,wy1,wx2,wy2;
1419                 cworld->TransformPoint( x1, i, wx1, wy1 );
1420                 cworld->TransformPoint( x2, i, wx2, wy2 );
1421                 int dx1,dy1,dx2,dy2;
1422                 dx1 = m_admin->LogicalToDeviceX( wx1 );
1423                 dy1 = m_admin->LogicalToDeviceY( wy1 );
1424                 dx2 = m_admin->LogicalToDeviceX( wx2 );
1425                 dy2 = m_admin->LogicalToDeviceY( wy2 );
1426
1427                 //TODO KKK need real line clipping here since line can be rotated.
1428                 if (0 && cworld->IsIdentity())
1429                 {
1430                     if (dx1 < clip_x) dx1=clip_x;
1431                     if (dx2 > clip_x + clip_width) dx2=clip_x + clip_width;
1432                     if ((dy1 >  clip_y) && dy1 < clip_y + clip_height)
1433                         dc->DrawLine( dx1, dy1, dx2, dy2 );
1434                 }
1435                 else
1436                 {
1437                     dc->DrawLine( dx1, dy1, dx2, dy2 );
1438                 }
1439
1440             }
1441             else
1442                 node = node->GetNext();
1443         }
1444     }
1445
1446     dc->DestroyClippingRegion();
1447 #endif
1448 }
1449
1450
1451
1452
1453