contrib/src/ogl/basic2.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        basic2.cpp
   3 // Purpose:     Basic OGL classes (2)
   4 // Author:      Julian Smart
   5 // Modified by:
   6 // Created:     12/07/98
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) Julian Smart
   9 // Licence:     wxWindows licence
  10 /////////////////////////////////////////////////////////////////////////////
  11
  12 #ifdef __GNUG__
  13 #pragma implementation "basicp.h"
  14 #endif
  15
  16 // For compilers that support precompilation, includes "wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #ifdef __BORLANDC__
  20 #pragma hdrstop
  21 #endif
  22
  23 #ifndef WX_PRECOMP
  24 #include <wx/wx.h>
  25 #endif
  26
  27 #if wxUSE_PROLOGIO
  28 #include <wx/deprecated/wxexpr.h>
  29 #endif
  30
  31 #ifdef new
  32 #undef new
  33 #endif
  34
  35 #include <stdio.h>
  36 #include <ctype.h>
  37 #include <math.h>
  38
  39 #include "wx/ogl/ogl.h"
  40
  41
  42 // Control point types
  43 // Rectangle and most other shapes
  44 #define CONTROL_POINT_VERTICAL   1
  45 #define CONTROL_POINT_HORIZONTAL 2
  46 #define CONTROL_POINT_DIAGONAL   3
  47
  48 // Line
  49 #define CONTROL_POINT_ENDPOINT_TO 4
  50 #define CONTROL_POINT_ENDPOINT_FROM 5
  51 #define CONTROL_POINT_LINE       6
  52
  53 // Two stage construction: need to call Create
  54 IMPLEMENT_DYNAMIC_CLASS(wxPolygonShape, wxShape)
  55
  56 wxPolygonShape::wxPolygonShape()
  57 {
  58   m_points = NULL;
  59   m_originalPoints = NULL;
  60 }
  61
  62 void wxPolygonShape::Create(wxList *the_points)
  63 {
  64   ClearPoints();
  65
  66   m_originalPoints = the_points;
  67
  68   // Duplicate the list of points
  69   m_points = new wxList;
  70
  71   wxNode *node = the_points->GetFirst();
  72   while (node)
  73   {
  74     wxRealPoint *point = (wxRealPoint *)node->GetData();
  75     wxRealPoint *new_point = new wxRealPoint(point->x, point->y);
  76     m_points->Append((wxObject*) new_point);
  77     node = node->GetNext();
  78   }
  79   CalculateBoundingBox();
  80   m_originalWidth = m_boundWidth;
  81   m_originalHeight = m_boundHeight;
  82   SetDefaultRegionSize();
  83 }
  84
  85 wxPolygonShape::~wxPolygonShape()
  86 {
  87     ClearPoints();
  88 }
  89
  90 void wxPolygonShape::ClearPoints()
  91 {
  92   if (m_points)
  93   {
  94     wxNode *node = m_points->GetFirst();
  95     while (node)
  96     {
  97       wxRealPoint *point = (wxRealPoint *)node->GetData();
  98       delete point;
  99       delete node;
 100       node = m_points->GetFirst();
 101     }
 102     delete m_points;
 103     m_points = NULL;
 104   }
 105   if (m_originalPoints)
 106   {
 107     wxNode *node = m_originalPoints->GetFirst();
 108     while (node)
 109     {
 110       wxRealPoint *point = (wxRealPoint *)node->GetData();
 111       delete point;
 112       delete node;
 113       node = m_originalPoints->GetFirst();
 114     }
 115     delete m_originalPoints;
 116     m_originalPoints = NULL;
 117   }
 118 }
 119
 120
 121 // Width and height. Centre of object is centre of box.
 122 void wxPolygonShape::GetBoundingBoxMin(double *width, double *height)
 123 {
 124   *width = m_boundWidth;
 125   *height = m_boundHeight;
 126 }
 127
 128 void wxPolygonShape::CalculateBoundingBox()
 129 {
 130   // Calculate bounding box at construction (and presumably resize) time
 131   double left = 10000;
 132   double right = -10000;
 133   double top = 10000;
 134   double bottom = -10000;
 135
 136   wxNode *node = m_points->GetFirst();
 137   while (node)
 138   {
 139     wxRealPoint *point = (wxRealPoint *)node->GetData();
 140     if (point->x < left) left = point->x;
 141     if (point->x > right) right = point->x;
 142
 143     if (point->y < top) top = point->y;
 144     if (point->y > bottom) bottom = point->y;
 145
 146     node = node->GetNext();
 147   }
 148   m_boundWidth = right - left;
 149   m_boundHeight = bottom - top;
 150 }
 151
 152 // Recalculates the centre of the polygon, and
 153 // readjusts the point offsets accordingly.
 154 // Necessary since the centre of the polygon
 155 // is expected to be the real centre of the bounding
 156 // box.
 157 void wxPolygonShape::CalculatePolygonCentre()
 158 {
 159   double left = 10000;
 160   double right = -10000;
 161   double top = 10000;
 162   double bottom = -10000;
 163
 164   wxNode *node = m_points->GetFirst();
 165   while (node)
 166   {
 167     wxRealPoint *point = (wxRealPoint *)node->GetData();
 168     if (point->x < left) left = point->x;
 169     if (point->x > right) right = point->x;
 170
 171     if (point->y < top) top = point->y;
 172     if (point->y > bottom) bottom = point->y;
 173
 174     node = node->GetNext();
 175   }
 176   double bwidth = right - left;
 177   double bheight = bottom - top;
 178
 179   double newCentreX = (double)(left + (bwidth/2.0));
 180   double newCentreY = (double)(top + (bheight/2.0));
 181
 182   node = m_points->GetFirst();
 183   while (node)
 184   {
 185     wxRealPoint *point = (wxRealPoint *)node->GetData();
 186     point->x -= newCentreX;
 187     point->y -= newCentreY;
 188     node = node->GetNext();
 189   }
 190   m_xpos += newCentreX;
 191   m_ypos += newCentreY;
 192 }
 193
 194 bool PolylineHitTest(double n, double xvec[], double yvec[],
 195                            double x1, double y1, double x2, double y2)
 196 {
 197   bool isAHit = FALSE;
 198   int i;
 199   double lastx = xvec[0];
 200   double lasty = yvec[0];
 201
 202   double min_ratio = 1.0;
 203   double line_ratio;
 204   double other_ratio;
 205
 206 //  char buf[300];
 207   for (i = 1; i < n; i++)
 208   {
 209     oglCheckLineIntersection(x1, y1, x2, y2, lastx, lasty, xvec[i], yvec[i],
 210                             &line_ratio, &other_ratio);
 211     if (line_ratio != 1.0)
 212       isAHit = TRUE;
 213 //    sprintf(buf, "Line ratio = %.2f, other ratio = %.2f\n", line_ratio, other_ratio);
 214 //    ClipsErrorFunction(buf);
 215     lastx = xvec[i];
 216     lasty = yvec[i];
 217
 218     if (line_ratio < min_ratio)
 219       min_ratio = line_ratio;
 220   }
 221
 222   // Do last (implicit) line if last and first doubles are not identical
 223   if (!(xvec[0] == lastx && yvec[0] == lasty))
 224   {
 225     oglCheckLineIntersection(x1, y1, x2, y2, lastx, lasty, xvec[0], yvec[0],
 226                             &line_ratio, &other_ratio);
 227     if (line_ratio != 1.0)
 228       isAHit = TRUE;
 229 //    sprintf(buf, "Line ratio = %.2f, other ratio = %.2f\n", line_ratio, other_ratio);
 230 //    ClipsErrorFunction(buf);
 231
 232     if (line_ratio < min_ratio)
 233       min_ratio = line_ratio;
 234   }
 235 //  ClipsErrorFunction("\n");
 236   return isAHit;
 237 }
 238
 239 bool wxPolygonShape::HitTest(double x, double y, int *attachment, double *distance)
 240 {
 241   // Imagine four lines radiating from this point. If all of these lines hit the polygon,
 242   // we're inside it, otherwise we're not. Obviously we'd need more radiating lines
 243   // to be sure of correct results for very strange (concave) shapes.
 244   double endPointsX[4];
 245   double endPointsY[4];
 246   // North
 247   endPointsX[0] = x;
 248   endPointsY[0] = (double)(y - 1000.0);
 249   // East
 250   endPointsX[1] = (double)(x + 1000.0);
 251   endPointsY[1] = y;
 252   // South
 253   endPointsX[2] = x;
 254   endPointsY[2] = (double)(y + 1000.0);
 255   // West
 256   endPointsX[3] = (double)(x - 1000.0);
 257   endPointsY[3] = y;
 258
 259   // Store polygon points in an array
 260   int np = m_points->GetCount();
 261   double *xpoints = new double[np];
 262   double *ypoints = new double[np];
 263   wxNode *node = m_points->GetFirst();
 264   int i = 0;
 265   while (node)
 266   {
 267     wxRealPoint *point = (wxRealPoint *)node->GetData();
 268     xpoints[i] = point->x + m_xpos;
 269     ypoints[i] = point->y + m_ypos;
 270     node = node->GetNext();
 271     i ++;
 272   }
 273
 274   // We assume it's inside the polygon UNLESS one or more
 275   // lines don't hit the outline.
 276   bool isContained = TRUE;
 277
 278   int noPoints = 4;
 279   for (i = 0; i < noPoints; i++)
 280   {
 281     if (!PolylineHitTest(np, xpoints, ypoints, x, y, endPointsX[i], endPointsY[i]))
 282       isContained = FALSE;
 283   }
 284 /*
 285   if (isContained)
 286     ClipsErrorFunction("It's a hit!\n");
 287   else
 288     ClipsErrorFunction("No hit.\n");
 289 */
 290   delete[] xpoints;
 291   delete[] ypoints;
 292
 293   if (!isContained)
 294     return FALSE;
 295
 296   int nearest_attachment = 0;
 297
 298   // If a hit, check the attachment points within the object.
 299   int n = GetNumberOfAttachments();
 300   double nearest = 999999.0;
 301
 302   for (i = 0; i < n; i++)
 303   {
 304     double xp, yp;
 305     if (GetAttachmentPositionEdge(i, &xp, &yp))
 306     {
 307       double l = (double)sqrt(((xp - x) * (xp - x)) +
 308                  ((yp - y) * (yp - y)));
 309       if (l < nearest)
 310       {
 311         nearest = l;
 312         nearest_attachment = i;
 313       }
 314     }
 315   }
 316   *attachment = nearest_attachment;
 317   *distance = nearest;
 318   return TRUE;
 319 }
 320
 321 // Really need to be able to reset the shape! Otherwise, if the
 322 // points ever go to zero, we've lost it, and can't resize.
 323 void wxPolygonShape::SetSize(double new_width, double new_height, bool WXUNUSED(recursive))
 324 {
 325   SetAttachmentSize(new_width, new_height);
 326
 327   // Multiply all points by proportion of new size to old size
 328   double x_proportion = (double)(fabs(new_width/m_originalWidth));
 329   double y_proportion = (double)(fabs(new_height/m_originalHeight));
 330
 331   wxNode *node = m_points->GetFirst();
 332   wxNode *original_node = m_originalPoints->GetFirst();
 333   while (node && original_node)
 334   {
 335     wxRealPoint *point = (wxRealPoint *)node->GetData();
 336     wxRealPoint *original_point = (wxRealPoint *)original_node->GetData();
 337
 338     point->x = (original_point->x * x_proportion);
 339     point->y = (original_point->y * y_proportion);
 340
 341     node = node->GetNext();
 342     original_node = original_node->GetNext();
 343   }
 344
 345 //  CalculateBoundingBox();
 346   m_boundWidth = (double)fabs(new_width);
 347   m_boundHeight = (double)fabs(new_height);
 348   SetDefaultRegionSize();
 349 }
 350
 351 // Make the original points the same as the working points
 352 void wxPolygonShape::UpdateOriginalPoints()
 353 {
 354   if (!m_originalPoints) m_originalPoints = new wxList;
 355   wxNode *original_node = m_originalPoints->GetFirst();
 356   while (original_node)
 357   {
 358     wxNode *next_node = original_node->GetNext();
 359     wxRealPoint *original_point = (wxRealPoint *)original_node->GetData();
 360     delete original_point;
 361     delete original_node;
 362
 363     original_node = next_node;
 364   }
 365
 366   wxNode *node = m_points->GetFirst();
 367   while (node)
 368   {
 369     wxRealPoint *point = (wxRealPoint *)node->GetData();
 370     wxRealPoint *original_point = new wxRealPoint(point->x, point->y);
 371     m_originalPoints->Append((wxObject*) original_point);
 372
 373     node = node->GetNext();
 374   }
 375   CalculateBoundingBox();
 376   m_originalWidth = m_boundWidth;
 377   m_originalHeight = m_boundHeight;
 378 }
 379
 380 void wxPolygonShape::AddPolygonPoint(int pos)
 381 {
 382   wxNode *node = m_points->Item(pos);
 383   if (!node) node = m_points->GetFirst();
 384   wxRealPoint *firstPoint = (wxRealPoint *)node->GetData();
 385
 386   wxNode *node2 = m_points->Item(pos + 1);
 387   if (!node2) node2 = m_points->GetFirst();
 388   wxRealPoint *secondPoint = (wxRealPoint *)node2->GetData();
 389
 390   double x = (double)((secondPoint->x - firstPoint->x)/2.0 + firstPoint->x);
 391   double y = (double)((secondPoint->y - firstPoint->y)/2.0 + firstPoint->y);
 392   wxRealPoint *point = new wxRealPoint(x, y);
 393
 394   if (pos >= (int) (m_points->GetCount() - 1))
 395     m_points->Append((wxObject*) point);
 396   else
 397     m_points->Insert(node2, (wxObject*) point);
 398
 399   UpdateOriginalPoints();
 400
 401   if (m_selected)
 402   {
 403     DeleteControlPoints();
 404     MakeControlPoints();
 405   }
 406 }
 407
 408 void wxPolygonShape::DeletePolygonPoint(int pos)
 409 {
 410   wxNode *node = m_points->Item(pos);
 411   if (node)
 412   {
 413     wxRealPoint *point = (wxRealPoint *)node->GetData();
 414     delete point;
 415     delete node;
 416     UpdateOriginalPoints();
 417     if (m_selected)
 418     {
 419       DeleteControlPoints();
 420       MakeControlPoints();
 421     }
 422   }
 423 }
 424
 425 // Assume (x1, y1) is centre of box (most generally, line end at box)
 426 bool wxPolygonShape::GetPerimeterPoint(double x1, double y1,
 427                                      double x2, double y2,
 428                                      double *x3, double *y3)
 429 {
 430   int n = m_points->GetCount();
 431
 432   // First check for situation where the line is vertical,
 433   // and we would want to connect to a point on that vertical --
 434   // oglFindEndForPolyline can't cope with this (the arrow
 435   // gets drawn to the wrong place).
 436   if ((m_attachmentMode == ATTACHMENT_MODE_NONE) && (x1 == x2))
 437   {
 438     // Look for the point we'd be connecting to. This is
 439     // a heuristic...
 440     wxNode *node = m_points->GetFirst();
 441     while (node)
 442     {
 443       wxRealPoint *point = (wxRealPoint *)node->GetData();
 444       if (point->x == 0.0)
 445       {
 446         if ((y2 > y1) && (point->y > 0.0))
 447         {
 448           *x3 = point->x + m_xpos;
 449           *y3 = point->y + m_ypos;
 450           return TRUE;
 451         }
 452         else if ((y2 < y1) && (point->y < 0.0))
 453         {
 454           *x3 = point->x + m_xpos;
 455           *y3 = point->y + m_ypos;
 456           return TRUE;
 457         }
 458       }
 459       node = node->GetNext();
 460     }
 461   }
 462
 463   double *xpoints = new double[n];
 464   double *ypoints = new double[n];
 465
 466   wxNode *node = m_points->GetFirst();
 467   int i = 0;
 468   while (node)
 469   {
 470     wxRealPoint *point = (wxRealPoint *)node->GetData();
 471     xpoints[i] = point->x + m_xpos;
 472     ypoints[i] = point->y + m_ypos;
 473     node = node->GetNext();
 474     i ++;
 475   }
 476
 477   oglFindEndForPolyline(n, xpoints, ypoints,
 478                         x1, y1, x2, y2, x3, y3);
 479
 480   delete[] xpoints;
 481   delete[] ypoints;
 482
 483   return TRUE;
 484 }
 485
 486 void wxPolygonShape::OnDraw(wxDC& dc)
 487 {
 488     int n = m_points->GetCount();
 489     wxPoint *intPoints = new wxPoint[n];
 490     int i;
 491     for (i = 0; i < n; i++)
 492     {
 493       wxRealPoint* point = (wxRealPoint*) m_points->Item(i)->GetData();
 494       intPoints[i].x = WXROUND(point->x);
 495       intPoints[i].y = WXROUND(point->y);
 496     }
 497
 498     if (m_shadowMode != SHADOW_NONE)
 499     {
 500       if (m_shadowBrush)
 501         dc.SetBrush(* m_shadowBrush);
 502       dc.SetPen(* g_oglTransparentPen);
 503
 504       dc.DrawPolygon(n, intPoints, WXROUND(m_xpos + m_shadowOffsetX), WXROUND(m_ypos + m_shadowOffsetY));
 505     }
 506
 507     if (m_pen)
 508     {
 509       if (m_pen->GetWidth() == 0)
 510         dc.SetPen(* g_oglTransparentPen);
 511       else
 512         dc.SetPen(* m_pen);
 513     }
 514     if (m_brush)
 515       dc.SetBrush(* m_brush);
 516     dc.DrawPolygon(n, intPoints, WXROUND(m_xpos), WXROUND(m_ypos));
 517
 518     delete[] intPoints;
 519 }
 520
 521 void wxPolygonShape::OnDrawOutline(wxDC& dc, double x, double y, double w, double h)
 522 {
 523   dc.SetBrush(* wxTRANSPARENT_BRUSH);
 524   // Multiply all points by proportion of new size to old size
 525   double x_proportion = (double)(fabs(w/m_originalWidth));
 526   double y_proportion = (double)(fabs(h/m_originalHeight));
 527
 528   int n = m_originalPoints->GetCount();
 529   wxPoint *intPoints = new wxPoint[n];
 530   int i;
 531   for (i = 0; i < n; i++)
 532   {
 533     wxRealPoint* point = (wxRealPoint*) m_originalPoints->Item(i)->GetData();
 534     intPoints[i].x = WXROUND(x_proportion * point->x);
 535     intPoints[i].y = WXROUND(y_proportion * point->y);
 536   }
 537   dc.DrawPolygon(n, intPoints, WXROUND(x), WXROUND(y));
 538   delete[] intPoints;
 539 }
 540
 541 // Make as many control points as there are vertices.
 542 void wxPolygonShape::MakeControlPoints()
 543 {
 544   wxNode *node = m_points->GetFirst();
 545   while (node)
 546   {
 547     wxRealPoint *point = (wxRealPoint *)node->GetData();
 548     wxPolygonControlPoint *control = new wxPolygonControlPoint(m_canvas, this, CONTROL_POINT_SIZE,
 549       point, point->x, point->y);
 550     m_canvas->AddShape(control);
 551     m_controlPoints.Append(control);
 552     node = node->GetNext();
 553   }
 554 }
 555
 556 void wxPolygonShape::ResetControlPoints()
 557 {
 558   wxNode *node = m_points->GetFirst();
 559   wxNode *controlPointNode = m_controlPoints.GetFirst();
 560   while (node && controlPointNode)
 561   {
 562     wxRealPoint *point = (wxRealPoint *)node->GetData();
 563     wxPolygonControlPoint *controlPoint = (wxPolygonControlPoint *)controlPointNode->GetData();
 564
 565     controlPoint->m_xoffset = point->x;
 566     controlPoint->m_yoffset = point->y;
 567     controlPoint->m_polygonVertex = point;
 568
 569     node = node->GetNext();
 570     controlPointNode = controlPointNode->GetNext();
 571   }
 572 }
 573
 574
 575 #if wxUSE_PROLOGIO
 576 void wxPolygonShape::WriteAttributes(wxExpr *clause)
 577 {
 578   wxShape::WriteAttributes(clause);
 579
 580   clause->AddAttributeValue(wxT("x"), m_xpos);
 581   clause->AddAttributeValue(wxT("y"), m_ypos);
 582
 583   // Make a list of lists for the coordinates
 584   wxExpr *list = new wxExpr(wxExprList);
 585   wxNode *node = m_points->GetFirst();
 586   while (node)
 587   {
 588     wxRealPoint *point = (wxRealPoint *)node->GetData();
 589     wxExpr *point_list = new wxExpr(wxExprList);
 590     wxExpr *x_expr = new wxExpr((double)point->x);
 591     wxExpr *y_expr = new wxExpr((double)point->y);
 592
 593     point_list->Append(x_expr);
 594     point_list->Append(y_expr);
 595     list->Append(point_list);
 596
 597     node = node->GetNext();
 598   }
 599   clause->AddAttributeValue(wxT("points"), list);
 600
 601   // Save the original (unscaled) points
 602   list = new wxExpr(wxExprList);
 603   node = m_originalPoints->GetFirst();
 604   while (node)
 605   {
 606     wxRealPoint *point = (wxRealPoint *)node->GetData();
 607     wxExpr *point_list = new wxExpr(wxExprList);
 608     wxExpr *x_expr = new wxExpr((double) point->x);
 609     wxExpr *y_expr = new wxExpr((double) point->y);
 610     point_list->Append(x_expr);
 611     point_list->Append(y_expr);
 612     list->Append(point_list);
 613
 614     node = node->GetNext();
 615   }
 616   clause->AddAttributeValue(wxT("m_originalPoints"), list);
 617 }
 618
 619 void wxPolygonShape::ReadAttributes(wxExpr *clause)
 620 {
 621   wxShape::ReadAttributes(clause);
 622
 623   // Read a list of lists
 624   m_points = new wxList;
 625   m_originalPoints = new wxList;
 626
 627   wxExpr *points_list = NULL;
 628   clause->AssignAttributeValue(wxT("points"), &points_list);
 629
 630   // If no points_list, don't crash!! Assume a diamond instead.
 631   double the_height = 100.0;
 632   double the_width = 100.0;
 633   if (!points_list)
 634   {
 635     wxRealPoint *point = new wxRealPoint(0.0, (-the_height/2));
 636     m_points->Append((wxObject*) point);
 637
 638     point = new wxRealPoint((the_width/2), 0.0);
 639     m_points->Append((wxObject*) point);
 640
 641     point = new wxRealPoint(0.0, (the_height/2));
 642     m_points->Append((wxObject*) point);
 643
 644     point = new wxRealPoint((-the_width/2), 0.0);
 645     m_points->Append((wxObject*) point);
 646
 647     point = new wxRealPoint(0.0, (-the_height/2));
 648     m_points->Append((wxObject*) point);
 649   }
 650   else
 651   {
 652     wxExpr *node = points_list->value.first;
 653
 654     while (node)
 655     {
 656       wxExpr *xexpr = node->value.first;
 657       long x = xexpr->IntegerValue();
 658
 659       wxExpr *yexpr = xexpr->next;
 660       long y = yexpr->IntegerValue();
 661
 662       wxRealPoint *point = new wxRealPoint((double)x, (double)y);
 663       m_points->Append((wxObject*) point);
 664
 665       node = node->next;
 666     }
 667   }
 668
 669   points_list = NULL;
 670   clause->AssignAttributeValue(wxT("m_originalPoints"), &points_list);
 671
 672   // If no points_list, don't crash!! Assume a diamond instead.
 673   if (!points_list)
 674   {
 675     wxRealPoint *point = new wxRealPoint(0.0, (-the_height/2));
 676     m_originalPoints->Append((wxObject*) point);
 677
 678     point = new wxRealPoint((the_width/2), 0.0);
 679     m_originalPoints->Append((wxObject*) point);
 680
 681     point = new wxRealPoint(0.0, (the_height/2));
 682     m_originalPoints->Append((wxObject*) point);
 683
 684     point = new wxRealPoint((-the_width/2), 0.0);
 685     m_originalPoints->Append((wxObject*) point);
 686
 687     point = new wxRealPoint(0.0, (-the_height/2));
 688     m_originalPoints->Append((wxObject*) point);
 689
 690     m_originalWidth = the_width;
 691     m_originalHeight = the_height;
 692   }
 693   else
 694   {
 695     wxExpr *node = points_list->value.first;
 696     double min_x = 1000;
 697     double min_y = 1000;
 698     double max_x = -1000;
 699     double max_y = -1000;
 700     while (node)
 701     {
 702       wxExpr *xexpr = node->value.first;
 703       long x = xexpr->IntegerValue();
 704
 705       wxExpr *yexpr = xexpr->next;
 706       long y = yexpr->IntegerValue();
 707
 708       wxRealPoint *point = new wxRealPoint((double)x, (double)y);
 709       m_originalPoints->Append((wxObject*) point);
 710
 711       if (x < min_x)
 712         min_x = (double)x;
 713       if (y < min_y)
 714         min_y = (double)y;
 715       if (x > max_x)
 716         max_x = (double)x;
 717       if (y > max_y)
 718         max_y = (double)y;
 719
 720       node = node->next;
 721     }
 722     m_originalWidth = max_x - min_x;
 723     m_originalHeight = max_y - min_y;
 724   }
 725
 726   CalculateBoundingBox();
 727 }
 728 #endif
 729
 730 void wxPolygonShape::Copy(wxShape& copy)
 731 {
 732   wxShape::Copy(copy);
 733
 734   wxASSERT( copy.IsKindOf(CLASSINFO(wxPolygonShape)) );
 735
 736   wxPolygonShape& polyCopy = (wxPolygonShape&) copy;
 737
 738   polyCopy.ClearPoints();
 739
 740   polyCopy.m_points = new wxList;
 741   polyCopy.m_originalPoints = new wxList;
 742
 743   wxNode *node = m_points->GetFirst();
 744   while (node)
 745   {
 746     wxRealPoint *point = (wxRealPoint *)node->GetData();
 747     wxRealPoint *new_point = new wxRealPoint(point->x, point->y);
 748     polyCopy.m_points->Append((wxObject*) new_point);
 749     node = node->GetNext();
 750   }
 751   node = m_originalPoints->GetFirst();
 752   while (node)
 753   {
 754     wxRealPoint *point = (wxRealPoint *)node->GetData();
 755     wxRealPoint *new_point = new wxRealPoint(point->x, point->y);
 756     polyCopy.m_originalPoints->Append((wxObject*) new_point);
 757     node = node->GetNext();
 758   }
 759   polyCopy.m_boundWidth = m_boundWidth;
 760   polyCopy.m_boundHeight = m_boundHeight;
 761   polyCopy.m_originalWidth = m_originalWidth;
 762   polyCopy.m_originalHeight = m_originalHeight;
 763 }
 764
 765 int wxPolygonShape::GetNumberOfAttachments() const
 766 {
 767   int maxN = (m_points ? (m_points->GetCount() - 1) : 0);
 768   wxNode *node = m_attachmentPoints.GetFirst();
 769   while (node)
 770   {
 771     wxAttachmentPoint *point = (wxAttachmentPoint *)node->GetData();
 772     if (point->m_id > maxN)
 773       maxN = point->m_id;
 774     node = node->GetNext();
 775   }
 776   return maxN+1;;
 777 }
 778
 779 bool wxPolygonShape::GetAttachmentPosition(int attachment, double *x, double *y,
 780                                          int nth, int no_arcs, wxLineShape *line)
 781 {
 782   if ((m_attachmentMode == ATTACHMENT_MODE_EDGE) && m_points && attachment < (int) m_points->GetCount())
 783   {
 784     wxRealPoint *point = (wxRealPoint *)m_points->Item(attachment)->GetData();
 785     *x = point->x + m_xpos;
 786     *y = point->y + m_ypos;
 787     return TRUE;
 788   }
 789   else
 790   { return wxShape::GetAttachmentPosition(attachment, x, y, nth, no_arcs, line); }
 791 }
 792
 793 bool wxPolygonShape::AttachmentIsValid(int attachment) const
 794 {
 795   if (!m_points)
 796     return FALSE;
 797
 798   if ((attachment >= 0) && (attachment < (int) m_points->GetCount()))
 799     return TRUE;
 800
 801   wxNode *node = m_attachmentPoints.GetFirst();
 802   while (node)
 803   {
 804     wxAttachmentPoint *point = (wxAttachmentPoint *)node->GetData();
 805     if (point->m_id == attachment)
 806       return TRUE;
 807     node = node->GetNext();
 808   }
 809   return FALSE;
 810 }
 811
 812 // Rotate about the given axis by the given amount in radians
 813 void wxPolygonShape::Rotate(double x, double y, double theta)
 814 {
 815     double actualTheta = theta-m_rotation;
 816
 817     // Rotate attachment points
 818     double sinTheta = (double)sin(actualTheta);
 819     double cosTheta = (double)cos(actualTheta);
 820     wxNode *node = m_attachmentPoints.GetFirst();
 821     while (node)
 822     {
 823         wxAttachmentPoint *point = (wxAttachmentPoint *)node->GetData();
 824         double x1 = point->m_x;
 825         double y1 = point->m_y;
 826         point->m_x = x1*cosTheta - y1*sinTheta + x*(1.0 - cosTheta) + y*sinTheta;
 827         point->m_y = x1*sinTheta + y1*cosTheta + y*(1.0 - cosTheta) + x*sinTheta;
 828         node = node->GetNext();
 829     }
 830
 831     node = m_points->GetFirst();
 832     while (node)
 833     {
 834         wxRealPoint *point = (wxRealPoint *)node->GetData();
 835         double x1 = point->x;
 836         double y1 = point->y;
 837         point->x = x1*cosTheta - y1*sinTheta + x*(1.0 - cosTheta) + y*sinTheta;
 838         point->y = x1*sinTheta + y1*cosTheta + y*(1.0 - cosTheta) + x*sinTheta;
 839         node = node->GetNext();
 840     }
 841     node = m_originalPoints->GetFirst();
 842     while (node)
 843     {
 844         wxRealPoint *point = (wxRealPoint *)node->GetData();
 845         double x1 = point->x;
 846         double y1 = point->y;
 847         point->x = x1*cosTheta - y1*sinTheta + x*(1.0 - cosTheta) + y*sinTheta;
 848         point->y = x1*sinTheta + y1*cosTheta + y*(1.0 - cosTheta) + x*sinTheta;
 849         node = node->GetNext();
 850     }
 851
 852     m_rotation = theta;
 853
 854     CalculatePolygonCentre();
 855     CalculateBoundingBox();
 856     ResetControlPoints();
 857 }
 858
 859 // Rectangle object
 860
 861 IMPLEMENT_DYNAMIC_CLASS(wxRectangleShape, wxShape)
 862
 863 wxRectangleShape::wxRectangleShape(double w, double h)
 864 {
 865   m_width = w; m_height = h; m_cornerRadius = 0.0;
 866   SetDefaultRegionSize();
 867 }
 868
 869 void wxRectangleShape::OnDraw(wxDC& dc)
 870 {
 871     double x1 = (double)(m_xpos - m_width/2.0);
 872     double y1 = (double)(m_ypos - m_height/2.0);
 873
 874     if (m_shadowMode != SHADOW_NONE)
 875     {
 876       if (m_shadowBrush)
 877         dc.SetBrush(* m_shadowBrush);
 878       dc.SetPen(* g_oglTransparentPen);
 879
 880       if (m_cornerRadius != 0.0)
 881         dc.DrawRoundedRectangle(WXROUND(x1 + m_shadowOffsetX), WXROUND(y1 + m_shadowOffsetY),
 882                                  WXROUND(m_width), WXROUND(m_height), m_cornerRadius);
 883       else
 884         dc.DrawRectangle(WXROUND(x1 + m_shadowOffsetX), WXROUND(y1 + m_shadowOffsetY), WXROUND(m_width), WXROUND(m_height));
 885     }
 886
 887     if (m_pen)
 888     {
 889       if (m_pen->GetWidth() == 0)
 890         dc.SetPen(* g_oglTransparentPen);
 891       else
 892         dc.SetPen(* m_pen);
 893     }
 894     if (m_brush)
 895       dc.SetBrush(* m_brush);
 896
 897     if (m_cornerRadius != 0.0)
 898       dc.DrawRoundedRectangle(WXROUND(x1), WXROUND(y1), WXROUND(m_width), WXROUND(m_height), m_cornerRadius);
 899     else
 900       dc.DrawRectangle(WXROUND(x1), WXROUND(y1), WXROUND(m_width), WXROUND(m_height));
 901 }
 902
 903 void wxRectangleShape::GetBoundingBoxMin(double *the_width, double *the_height)
 904 {
 905   *the_width = m_width;
 906   *the_height = m_height;
 907 }
 908
 909 void wxRectangleShape::SetSize(double x, double y, bool WXUNUSED(recursive))
 910 {
 911   SetAttachmentSize(x, y);
 912   m_width = (double)wxMax(x, 1.0);
 913   m_height = (double)wxMax(y, 1.0);
 914   SetDefaultRegionSize();
 915 }
 916
 917 void wxRectangleShape::SetCornerRadius(double rad)
 918 {
 919   m_cornerRadius = rad;
 920 }
 921
 922 // Assume (x1, y1) is centre of box (most generally, line end at box)
 923 bool wxRectangleShape::GetPerimeterPoint(double WXUNUSED(x1), double WXUNUSED(y1),
 924                                      double x2, double y2,
 925                                      double *x3, double *y3)
 926 {
 927   double bound_x, bound_y;
 928   GetBoundingBoxMax(&bound_x, &bound_y);
 929   oglFindEndForBox(bound_x, bound_y, m_xpos, m_ypos, x2, y2, x3, y3);
 930
 931   return TRUE;
 932 }
 933
 934 #if wxUSE_PROLOGIO
 935 void wxRectangleShape::WriteAttributes(wxExpr *clause)
 936 {
 937   wxShape::WriteAttributes(clause);
 938   clause->AddAttributeValue(wxT("x"), m_xpos);
 939   clause->AddAttributeValue(wxT("y"), m_ypos);
 940
 941   clause->AddAttributeValue(wxT("width"), m_width);
 942   clause->AddAttributeValue(wxT("height"), m_height);
 943   if (m_cornerRadius != 0.0)
 944     clause->AddAttributeValue(wxT("corner"), m_cornerRadius);
 945 }
 946
 947 void wxRectangleShape::ReadAttributes(wxExpr *clause)
 948 {
 949   wxShape::ReadAttributes(clause);
 950   clause->AssignAttributeValue(wxT("width"), &m_width);
 951   clause->AssignAttributeValue(wxT("height"), &m_height);
 952   clause->AssignAttributeValue(wxT("corner"), &m_cornerRadius);
 953
 954   // In case we're reading an old file, set the region's size
 955   if (m_regions.GetCount() == 1)
 956   {
 957     wxShapeRegion *region = (wxShapeRegion *)m_regions.GetFirst()->GetData();
 958     region->SetSize(m_width, m_height);
 959   }
 960 }
 961 #endif
 962
 963 void wxRectangleShape::Copy(wxShape& copy)
 964 {
 965   wxShape::Copy(copy);
 966
 967   wxASSERT( copy.IsKindOf(CLASSINFO(wxRectangleShape)) );
 968
 969   wxRectangleShape& rectCopy = (wxRectangleShape&) copy;
 970   rectCopy.m_width = m_width;
 971   rectCopy.m_height = m_height;
 972   rectCopy.m_cornerRadius = m_cornerRadius;
 973 }
 974
 975 int wxRectangleShape::GetNumberOfAttachments() const
 976 {
 977   return wxShape::GetNumberOfAttachments();
 978 }
 979
 980
 981 // There are 4 attachment points on a rectangle - 0 = top, 1 = right, 2 = bottom,
 982 // 3 = left.
 983 bool wxRectangleShape::GetAttachmentPosition(int attachment, double *x, double *y,
 984                                          int nth, int no_arcs, wxLineShape *line)
 985 {
 986     return wxShape::GetAttachmentPosition(attachment, x, y, nth, no_arcs, line);
 987 }
 988
 989 // Text object (no box)
 990
 991 IMPLEMENT_DYNAMIC_CLASS(wxTextShape, wxRectangleShape)
 992
 993 wxTextShape::wxTextShape(double width, double height):
 994   wxRectangleShape(width, height)
 995 {
 996 }
 997
 998 void wxTextShape::OnDraw(wxDC& WXUNUSED(dc))
 999 {
1000 }
1001
1002 void wxTextShape::Copy(wxShape& copy)
1003 {
1004   wxRectangleShape::Copy(copy);
1005 }
1006
1007 #if wxUSE_PROLOGIO
1008 void wxTextShape::WriteAttributes(wxExpr *clause)
1009 {
1010   wxRectangleShape::WriteAttributes(clause);
1011 }
1012 #endif
1013
1014 // Ellipse object
1015
1016 IMPLEMENT_DYNAMIC_CLASS(wxEllipseShape, wxShape)
1017
1018 wxEllipseShape::wxEllipseShape(double w, double h)
1019 {
1020   m_width = w; m_height = h;
1021   SetDefaultRegionSize();
1022 }
1023
1024 void wxEllipseShape::GetBoundingBoxMin(double *w, double *h)
1025 {
1026   *w = m_width; *h = m_height;
1027 }
1028
1029 bool wxEllipseShape::GetPerimeterPoint(double x1, double y1,
1030                                       double x2, double y2,
1031                                       double *x3, double *y3)
1032 {
1033   double bound_x, bound_y;
1034   GetBoundingBoxMax(&bound_x, &bound_y);
1035
1036 //  oglFindEndForBox(bound_x, bound_y, m_xpos, m_ypos, x2, y2, x3, y3);
1037   oglDrawArcToEllipse(m_xpos, m_ypos, bound_x, bound_y, x2, y2, x1, y1, x3, y3);
1038
1039   return TRUE;
1040 }
1041
1042 void wxEllipseShape::OnDraw(wxDC& dc)
1043 {
1044     if (m_shadowMode != SHADOW_NONE)
1045     {
1046       if (m_shadowBrush)
1047         dc.SetBrush(* m_shadowBrush);
1048       dc.SetPen(* g_oglTransparentPen);
1049       dc.DrawEllipse((long) ((m_xpos - GetWidth()/2) + m_shadowOffsetX),
1050                       (long) ((m_ypos - GetHeight()/2) + m_shadowOffsetY),
1051                       (long) GetWidth(), (long) GetHeight());
1052     }
1053
1054     if (m_pen)
1055     {
1056       if (m_pen->GetWidth() == 0)
1057         dc.SetPen(* g_oglTransparentPen);
1058       else
1059         dc.SetPen(* m_pen);
1060     }
1061     if (m_brush)
1062       dc.SetBrush(* m_brush);
1063     dc.DrawEllipse((long) (m_xpos - GetWidth()/2), (long) (m_ypos - GetHeight()/2), (long) GetWidth(), (long) GetHeight());
1064 }
1065
1066 void wxEllipseShape::SetSize(double x, double y, bool WXUNUSED(recursive))
1067 {
1068   SetAttachmentSize(x, y);
1069   m_width = x;
1070   m_height = y;
1071   SetDefaultRegionSize();
1072 }
1073
1074 #if wxUSE_PROLOGIO
1075 void wxEllipseShape::WriteAttributes(wxExpr *clause)
1076 {
1077   wxShape::WriteAttributes(clause);
1078   clause->AddAttributeValue(wxT("x"), m_xpos);
1079   clause->AddAttributeValue(wxT("y"), m_ypos);
1080
1081   clause->AddAttributeValue(wxT("width"), m_width);
1082   clause->AddAttributeValue(wxT("height"), m_height);
1083 }
1084
1085 void wxEllipseShape::ReadAttributes(wxExpr *clause)
1086 {
1087   wxShape::ReadAttributes(clause);
1088   clause->AssignAttributeValue(wxT("width"), &m_width);
1089   clause->AssignAttributeValue(wxT("height"), &m_height);
1090
1091   // In case we're reading an old file, set the region's size
1092   if (m_regions.GetCount() == 1)
1093   {
1094     wxShapeRegion *region = (wxShapeRegion *)m_regions.GetFirst()->GetData();
1095     region->SetSize(m_width, m_height);
1096   }
1097 }
1098 #endif
1099
1100 void wxEllipseShape::Copy(wxShape& copy)
1101 {
1102   wxShape::Copy(copy);
1103
1104   wxASSERT( copy.IsKindOf(CLASSINFO(wxEllipseShape)) );
1105
1106   wxEllipseShape& ellipseCopy = (wxEllipseShape&) copy;
1107
1108   ellipseCopy.m_width = m_width;
1109   ellipseCopy.m_height = m_height;
1110 }
1111
1112 int wxEllipseShape::GetNumberOfAttachments() const
1113 {
1114   return wxShape::GetNumberOfAttachments();
1115 }
1116
1117 // There are 4 attachment points on an ellipse - 0 = top, 1 = right, 2 = bottom,
1118 // 3 = left.
1119 bool wxEllipseShape::GetAttachmentPosition(int attachment, double *x, double *y,
1120                                          int nth, int no_arcs, wxLineShape *line)
1121 {
1122   if (m_attachmentMode == ATTACHMENT_MODE_BRANCHING)
1123     return wxShape::GetAttachmentPosition(attachment, x, y, nth, no_arcs, line);
1124
1125   if (m_attachmentMode != ATTACHMENT_MODE_NONE)
1126   {
1127     double top = (double)(m_ypos + m_height/2.0);
1128     double bottom = (double)(m_ypos - m_height/2.0);
1129     double left = (double)(m_xpos - m_width/2.0);
1130     double right = (double)(m_xpos + m_width/2.0);
1131
1132     int physicalAttachment = LogicalToPhysicalAttachment(attachment);
1133
1134     switch (physicalAttachment)
1135     {
1136       case 0:
1137       {
1138         if (m_spaceAttachments)
1139           *x = left + (nth + 1)*m_width/(no_arcs + 1);
1140         else *x = m_xpos;
1141         *y = top;
1142         // We now have the point on the bounding box: but get the point on the ellipse
1143         // by imagining a vertical line from (*x, m_ypos - m_height- 500) to (*x, m_ypos) intersecting
1144         // the ellipse.
1145         oglDrawArcToEllipse(m_xpos, m_ypos, m_width, m_height, *x, (double)(m_ypos-m_height-500), *x, m_ypos, x, y);
1146         break;
1147       }
1148       case 1:
1149       {
1150         *x = right;
1151         if (m_spaceAttachments)
1152           *y = bottom + (nth + 1)*m_height/(no_arcs + 1);
1153         else *y = m_ypos;
1154         oglDrawArcToEllipse(m_xpos, m_ypos, m_width, m_height, (double)(m_xpos+m_width+500), *y, m_xpos, *y, x, y);
1155         break;
1156       }
1157       case 2:
1158       {
1159         if (m_spaceAttachments)
1160           *x = left + (nth + 1)*m_width/(no_arcs + 1);
1161         else *x = m_xpos;
1162         *y = bottom;
1163         oglDrawArcToEllipse(m_xpos, m_ypos, m_width, m_height, *x, (double)(m_ypos+m_height+500), *x, m_ypos, x, y);
1164         break;
1165       }
1166       case 3:
1167       {
1168         *x = left;
1169         if (m_spaceAttachments)
1170           *y = bottom + (nth + 1)*m_height/(no_arcs + 1);
1171         else *y = m_ypos;
1172         oglDrawArcToEllipse(m_xpos, m_ypos, m_width, m_height, (double)(m_xpos-m_width-500), *y, m_xpos, *y, x, y);
1173         break;
1174       }
1175       default:
1176       {
1177         return wxShape::GetAttachmentPosition(attachment, x, y, nth, no_arcs, line);
1178       }
1179     }
1180     return TRUE;
1181   }
1182   else
1183   { *x = m_xpos; *y = m_ypos; return TRUE; }
1184 }
1185
1186
1187 // Circle object
1188 IMPLEMENT_DYNAMIC_CLASS(wxCircleShape, wxEllipseShape)
1189
1190 wxCircleShape::wxCircleShape(double diameter):wxEllipseShape(diameter, diameter)
1191 {
1192     SetMaintainAspectRatio(TRUE);
1193 }
1194
1195 void wxCircleShape::Copy(wxShape& copy)
1196 {
1197   wxEllipseShape::Copy(copy);
1198 }
1199
1200 bool wxCircleShape::GetPerimeterPoint(double WXUNUSED(x1), double WXUNUSED(y1),
1201                                       double x2, double y2,
1202                                       double *x3, double *y3)
1203 {
1204   oglFindEndForCircle(m_width/2,
1205                       m_xpos, m_ypos,  // Centre of circle
1206                       x2, y2,  // Other end of line
1207                       x3, y3);
1208
1209   return TRUE;
1210 }
1211
1212 // Control points
1213
1214 double wxControlPoint::sm_controlPointDragStartX = 0.0;
1215 double wxControlPoint::sm_controlPointDragStartY = 0.0;
1216 double wxControlPoint::sm_controlPointDragStartWidth = 0.0;
1217 double wxControlPoint::sm_controlPointDragStartHeight = 0.0;
1218 double wxControlPoint::sm_controlPointDragEndWidth = 0.0;
1219 double wxControlPoint::sm_controlPointDragEndHeight = 0.0;
1220 double wxControlPoint::sm_controlPointDragPosX = 0.0;
1221 double wxControlPoint::sm_controlPointDragPosY = 0.0;
1222
1223 IMPLEMENT_DYNAMIC_CLASS(wxControlPoint, wxRectangleShape)
1224
1225 wxControlPoint::wxControlPoint(wxShapeCanvas *theCanvas, wxShape *object, double size, double the_xoffset, double the_yoffset, int the_type):wxRectangleShape(size, size)
1226 {
1227   m_canvas = theCanvas;
1228   m_shape = object;
1229   m_xoffset = the_xoffset;
1230   m_yoffset = the_yoffset;
1231   m_type = the_type;
1232   SetPen(g_oglBlackForegroundPen);
1233   SetBrush(wxBLACK_BRUSH);
1234   m_oldCursor = NULL;
1235   m_visible = TRUE;
1236   m_eraseObject = TRUE;
1237 }
1238
1239 wxControlPoint::~wxControlPoint()
1240 {
1241 }
1242
1243 // Don't even attempt to draw any text - waste of time!
1244 void wxControlPoint::OnDrawContents(wxDC& WXUNUSED(dc))
1245 {
1246 }
1247
1248 void wxControlPoint::OnDraw(wxDC& dc)
1249 {
1250   m_xpos = m_shape->GetX() + m_xoffset;
1251   m_ypos = m_shape->GetY() + m_yoffset;
1252   wxRectangleShape::OnDraw(dc);
1253 }
1254
1255 void wxControlPoint::OnErase(wxDC& dc)
1256 {
1257   wxRectangleShape::OnErase(dc);
1258 }
1259
1260 // Implement resizing of canvas object
1261 void wxControlPoint::OnDragLeft(bool draw, double x, double y, int keys, int attachment)
1262 {
1263     m_shape->GetEventHandler()->OnSizingDragLeft(this, draw, x, y, keys, attachment);
1264 }
1265
1266 void wxControlPoint::OnBeginDragLeft(double x, double y, int keys, int attachment)
1267 {
1268     m_shape->GetEventHandler()->OnSizingBeginDragLeft(this, x, y, keys, attachment);
1269 }
1270
1271 void wxControlPoint::OnEndDragLeft(double x, double y, int keys, int attachment)
1272 {
1273     m_shape->GetEventHandler()->OnSizingEndDragLeft(this, x, y, keys, attachment);
1274 }
1275
1276 int wxControlPoint::GetNumberOfAttachments() const
1277 {
1278   return 1;
1279 }
1280
1281 bool wxControlPoint::GetAttachmentPosition(int WXUNUSED(attachment), double *x, double *y,
1282                                          int WXUNUSED(nth), int WXUNUSED(no_arcs), wxLineShape *WXUNUSED(line))
1283 {
1284   *x = m_xpos; *y = m_ypos;
1285   return TRUE;
1286 }
1287
1288 // Control points ('handles') redirect control to the actual shape, to make it easier
1289 // to override sizing behaviour.
1290 void wxShape::OnSizingDragLeft(wxControlPoint* pt, bool WXUNUSED(draw), double x, double y, int keys, int WXUNUSED(attachment))
1291 {
1292   double bound_x;
1293   double bound_y;
1294   this->GetBoundingBoxMin(&bound_x, &bound_y);
1295
1296   wxClientDC dc(GetCanvas());
1297   GetCanvas()->PrepareDC(dc);
1298
1299   dc.SetLogicalFunction(OGLRBLF);
1300
1301   wxPen dottedPen(wxColour(0, 0, 0), 1, wxDOT);
1302   dc.SetPen(dottedPen);
1303   dc.SetBrush((* wxTRANSPARENT_BRUSH));
1304
1305   if (this->GetCentreResize())
1306   {
1307     // Maintain the same centre point.
1308     double new_width = (double)(2.0*fabs(x - this->GetX()));
1309     double new_height = (double)(2.0*fabs(y - this->GetY()));
1310
1311     // Constrain sizing according to what control point you're dragging
1312     if (pt->m_type == CONTROL_POINT_HORIZONTAL)
1313     {
1314         if (GetMaintainAspectRatio())
1315         {
1316             new_height = bound_y*(new_width/bound_x);
1317         }
1318         else
1319             new_height = bound_y;
1320     }
1321     else if (pt->m_type == CONTROL_POINT_VERTICAL)
1322     {
1323         if (GetMaintainAspectRatio())
1324         {
1325             new_width = bound_x*(new_height/bound_y);
1326         }
1327         else
1328             new_width = bound_x;
1329     }
1330     else if (pt->m_type == CONTROL_POINT_DIAGONAL && (keys & KEY_SHIFT))
1331       new_height = bound_y*(new_width/bound_x);
1332
1333     if (this->GetFixedWidth())
1334       new_width = bound_x;
1335
1336     if (this->GetFixedHeight())
1337       new_height = bound_y;
1338
1339     pt->sm_controlPointDragEndWidth = new_width;
1340     pt->sm_controlPointDragEndHeight = new_height;
1341
1342     this->GetEventHandler()->OnDrawOutline(dc, this->GetX(), this->GetY(),
1343                                 new_width, new_height);
1344   }
1345   else
1346   {
1347     // Don't maintain the same centre point!
1348     double newX1 = wxMin(pt->sm_controlPointDragStartX, x);
1349     double newY1 = wxMin(pt->sm_controlPointDragStartY, y);
1350     double newX2 = wxMax(pt->sm_controlPointDragStartX, x);
1351     double newY2 = wxMax(pt->sm_controlPointDragStartY, y);
1352     if (pt->m_type == CONTROL_POINT_HORIZONTAL)
1353     {
1354       newY1 = pt->sm_controlPointDragStartY;
1355       newY2 = newY1 + pt->sm_controlPointDragStartHeight;
1356     }
1357     else if (pt->m_type == CONTROL_POINT_VERTICAL)
1358     {
1359       newX1 = pt->sm_controlPointDragStartX;
1360       newX2 = newX1 + pt->sm_controlPointDragStartWidth;
1361     }
1362     else if (pt->m_type == CONTROL_POINT_DIAGONAL && ((keys & KEY_SHIFT) || GetMaintainAspectRatio()))
1363     {
1364       double newH = (double)((newX2 - newX1)*(pt->sm_controlPointDragStartHeight/pt->sm_controlPointDragStartWidth));
1365       if (GetY() > pt->sm_controlPointDragStartY)
1366         newY2 = (double)(newY1 + newH);
1367       else
1368         newY1 = (double)(newY2 - newH);
1369     }
1370     double newWidth = (double)(newX2 - newX1);
1371     double newHeight = (double)(newY2 - newY1);
1372
1373     if (pt->m_type == CONTROL_POINT_VERTICAL && GetMaintainAspectRatio())
1374     {
1375         newWidth = bound_x * (newHeight/bound_y) ;
1376     }
1377
1378     if (pt->m_type == CONTROL_POINT_HORIZONTAL && GetMaintainAspectRatio())
1379     {
1380         newHeight = bound_y * (newWidth/bound_x) ;
1381     }
1382
1383     pt->sm_controlPointDragPosX = (double)(newX1 + (newWidth/2.0));
1384     pt->sm_controlPointDragPosY = (double)(newY1 + (newHeight/2.0));
1385     if (this->GetFixedWidth())
1386       newWidth = bound_x;
1387
1388     if (this->GetFixedHeight())
1389       newHeight = bound_y;
1390
1391     pt->sm_controlPointDragEndWidth = newWidth;
1392     pt->sm_controlPointDragEndHeight = newHeight;
1393     this->GetEventHandler()->OnDrawOutline(dc, pt->sm_controlPointDragPosX, pt->sm_controlPointDragPosY, newWidth, newHeight);
1394   }
1395 }
1396
1397 void wxShape::OnSizingBeginDragLeft(wxControlPoint* pt, double x, double y, int keys, int WXUNUSED(attachment))
1398 {
1399   m_canvas->CaptureMouse();
1400
1401   wxClientDC dc(GetCanvas());
1402   GetCanvas()->PrepareDC(dc);
1403 /*
1404   if (pt->m_eraseObject)
1405     this->Erase(dc);
1406 */
1407
1408   dc.SetLogicalFunction(OGLRBLF);
1409
1410   double bound_x;
1411   double bound_y;
1412   this->GetBoundingBoxMin(&bound_x, &bound_y);
1413
1414   // Choose the 'opposite corner' of the object as the stationary
1415   // point in case this is non-centring resizing.
1416   if (pt->GetX() < this->GetX())
1417     pt->sm_controlPointDragStartX = (double)(this->GetX() + (bound_x/2.0));
1418   else
1419     pt->sm_controlPointDragStartX = (double)(this->GetX() - (bound_x/2.0));
1420
1421   if (pt->GetY() < this->GetY())
1422     pt->sm_controlPointDragStartY = (double)(this->GetY() + (bound_y/2.0));
1423   else
1424     pt->sm_controlPointDragStartY = (double)(this->GetY() - (bound_y/2.0));
1425
1426   if (pt->m_type == CONTROL_POINT_HORIZONTAL)
1427     pt->sm_controlPointDragStartY = (double)(this->GetY() - (bound_y/2.0));
1428   else if (pt->m_type == CONTROL_POINT_VERTICAL)
1429     pt->sm_controlPointDragStartX = (double)(this->GetX() - (bound_x/2.0));
1430
1431   // We may require the old width and height.
1432   pt->sm_controlPointDragStartWidth = bound_x;
1433   pt->sm_controlPointDragStartHeight = bound_y;
1434
1435   wxPen dottedPen(wxColour(0, 0, 0), 1, wxDOT);
1436   dc.SetPen(dottedPen);
1437   dc.SetBrush((* wxTRANSPARENT_BRUSH));
1438
1439   if (this->GetCentreResize())
1440   {
1441     double new_width = (double)(2.0*fabs(x - this->GetX()));
1442     double new_height = (double)(2.0*fabs(y - this->GetY()));
1443
1444     // Constrain sizing according to what control point you're dragging
1445     if (pt->m_type == CONTROL_POINT_HORIZONTAL)
1446     {
1447         if (GetMaintainAspectRatio())
1448         {
1449             new_height = bound_y*(new_width/bound_x);
1450         }
1451         else
1452             new_height = bound_y;
1453     }
1454     else if (pt->m_type == CONTROL_POINT_VERTICAL)
1455     {
1456         if (GetMaintainAspectRatio())
1457         {
1458             new_width = bound_x*(new_height/bound_y);
1459         }
1460         else
1461             new_width = bound_x;
1462     }
1463     else if (pt->m_type == CONTROL_POINT_DIAGONAL && (keys & KEY_SHIFT))
1464       new_height = bound_y*(new_width/bound_x);
1465
1466     if (this->GetFixedWidth())
1467       new_width = bound_x;
1468
1469     if (this->GetFixedHeight())
1470       new_height = bound_y;
1471
1472     pt->sm_controlPointDragEndWidth = new_width;
1473     pt->sm_controlPointDragEndHeight = new_height;
1474     this->GetEventHandler()->OnDrawOutline(dc, this->GetX(), this->GetY(),
1475                                 new_width, new_height);
1476   }
1477   else
1478   {
1479     // Don't maintain the same centre point!
1480     double newX1 = wxMin(pt->sm_controlPointDragStartX, x);
1481     double newY1 = wxMin(pt->sm_controlPointDragStartY, y);
1482     double newX2 = wxMax(pt->sm_controlPointDragStartX, x);
1483     double newY2 = wxMax(pt->sm_controlPointDragStartY, y);
1484     if (pt->m_type == CONTROL_POINT_HORIZONTAL)
1485     {
1486       newY1 = pt->sm_controlPointDragStartY;
1487       newY2 = newY1 + pt->sm_controlPointDragStartHeight;
1488     }
1489     else if (pt->m_type == CONTROL_POINT_VERTICAL)
1490     {
1491       newX1 = pt->sm_controlPointDragStartX;
1492       newX2 = newX1 + pt->sm_controlPointDragStartWidth;
1493     }
1494     else if (pt->m_type == CONTROL_POINT_DIAGONAL && ((keys & KEY_SHIFT) || GetMaintainAspectRatio()))
1495     {
1496       double newH = (double)((newX2 - newX1)*(pt->sm_controlPointDragStartHeight/pt->sm_controlPointDragStartWidth));
1497       if (pt->GetY() > pt->sm_controlPointDragStartY)
1498         newY2 = (double)(newY1 + newH);
1499       else
1500         newY1 = (double)(newY2 - newH);
1501     }
1502     double newWidth = (double)(newX2 - newX1);
1503     double newHeight = (double)(newY2 - newY1);
1504
1505     if (pt->m_type == CONTROL_POINT_VERTICAL && GetMaintainAspectRatio())
1506     {
1507         newWidth = bound_x * (newHeight/bound_y) ;
1508     }
1509
1510     if (pt->m_type == CONTROL_POINT_HORIZONTAL && GetMaintainAspectRatio())
1511     {
1512         newHeight = bound_y * (newWidth/bound_x) ;
1513     }
1514
1515     pt->sm_controlPointDragPosX = (double)(newX1 + (newWidth/2.0));
1516     pt->sm_controlPointDragPosY = (double)(newY1 + (newHeight/2.0));
1517     if (this->GetFixedWidth())
1518       newWidth = bound_x;
1519
1520     if (this->GetFixedHeight())
1521       newHeight = bound_y;
1522
1523     pt->sm_controlPointDragEndWidth = newWidth;
1524     pt->sm_controlPointDragEndHeight = newHeight;
1525     this->GetEventHandler()->OnDrawOutline(dc, pt->sm_controlPointDragPosX, pt->sm_controlPointDragPosY, newWidth, newHeight);
1526   }
1527 }
1528
1529 void wxShape::OnSizingEndDragLeft(wxControlPoint* pt, double WXUNUSED(x), double WXUNUSED(y), int WXUNUSED(keys), int WXUNUSED(attachment))
1530 {
1531   wxClientDC dc(GetCanvas());
1532   GetCanvas()->PrepareDC(dc);
1533
1534   m_canvas->ReleaseMouse();
1535   dc.SetLogicalFunction(wxCOPY);
1536   this->Recompute();
1537   this->ResetControlPoints();
1538
1539   this->Erase(dc);
1540 /*
1541   if (!pt->m_eraseObject)
1542     this->Show(FALSE);
1543 */
1544
1545   this->SetSize(pt->sm_controlPointDragEndWidth, pt->sm_controlPointDragEndHeight);
1546
1547   // The next operation could destroy this control point (it does for label objects,
1548   // via formatting the text), so save all values we're going to use, or
1549   // we'll be accessing garbage.
1550   wxShape *theObject = this;
1551   wxShapeCanvas *theCanvas = m_canvas;
1552   bool eraseIt = pt->m_eraseObject;
1553
1554   if (theObject->GetCentreResize())
1555     theObject->Move(dc, theObject->GetX(), theObject->GetY());
1556   else
1557     theObject->Move(dc, pt->sm_controlPointDragPosX, pt->sm_controlPointDragPosY);
1558
1559 /*
1560   if (!eraseIt)
1561     theObject->Show(TRUE);
1562 */
1563
1564   // Recursively redraw links if we have a composite.
1565   if (theObject->GetChildren().GetCount() > 0)
1566     theObject->DrawLinks(dc, -1, TRUE);
1567
1568   double width, height;
1569   theObject->GetBoundingBoxMax(&width, &height);
1570   theObject->GetEventHandler()->OnEndSize(width, height);
1571
1572   if (!theCanvas->GetQuickEditMode() && eraseIt) theCanvas->Redraw(dc);
1573 }
1574
1575
1576
1577 // Polygon control points
1578
1579 IMPLEMENT_DYNAMIC_CLASS(wxPolygonControlPoint, wxControlPoint)
1580
1581 wxPolygonControlPoint::wxPolygonControlPoint(wxShapeCanvas *theCanvas, wxShape *object, double size,
1582   wxRealPoint *vertex, double the_xoffset, double the_yoffset):
1583   wxControlPoint(theCanvas, object, size, the_xoffset, the_yoffset, 0)
1584 {
1585   m_polygonVertex = vertex;
1586   m_originalDistance = 0.0;
1587 }
1588
1589 wxPolygonControlPoint::~wxPolygonControlPoint()
1590 {
1591 }
1592
1593 // Calculate what new size would be, at end of resize
1594 void wxPolygonControlPoint::CalculateNewSize(double x, double y)
1595 {
1596   double bound_x;
1597   double bound_y;
1598   GetShape()->GetBoundingBoxMin(&bound_x, &bound_y);
1599
1600   double dist = (double)sqrt((x - m_shape->GetX())*(x - m_shape->GetX()) +
1601                     (y - m_shape->GetY())*(y - m_shape->GetY()));
1602
1603   m_newSize.x = (double)(dist/this->m_originalDistance)*this->m_originalSize.x;
1604   m_newSize.y = (double)(dist/this->m_originalDistance)*this->m_originalSize.y;
1605 }
1606
1607
1608 // Implement resizing polygon or moving the vertex.
1609 void wxPolygonControlPoint::OnDragLeft(bool draw, double x, double y, int keys, int attachment)
1610 {
1611     m_shape->GetEventHandler()->OnSizingDragLeft(this, draw, x, y, keys, attachment);
1612 }
1613
1614 void wxPolygonControlPoint::OnBeginDragLeft(double x, double y, int keys, int attachment)
1615 {
1616     m_shape->GetEventHandler()->OnSizingBeginDragLeft(this, x, y, keys, attachment);
1617 }
1618
1619 void wxPolygonControlPoint::OnEndDragLeft(double x, double y, int keys, int attachment)
1620 {
1621     m_shape->GetEventHandler()->OnSizingEndDragLeft(this, x, y, keys, attachment);
1622 }
1623
1624 // Control points ('handles') redirect control to the actual shape, to make it easier
1625 // to override sizing behaviour.
1626 void wxPolygonShape::OnSizingDragLeft(wxControlPoint* pt, bool WXUNUSED(draw), double x, double y, int WXUNUSED(keys), int WXUNUSED(attachment))
1627 {
1628   wxPolygonControlPoint* ppt = (wxPolygonControlPoint*) pt;
1629
1630   wxClientDC dc(GetCanvas());
1631   GetCanvas()->PrepareDC(dc);
1632
1633   dc.SetLogicalFunction(OGLRBLF);
1634
1635   wxPen dottedPen(wxColour(0, 0, 0), 1, wxDOT);
1636   dc.SetPen(dottedPen);
1637   dc.SetBrush((* wxTRANSPARENT_BRUSH));
1638
1639   #if 0 // keys & KEY_CTRL)
1640   {
1641     // TODO: mend this code. Currently we rely on altering the
1642     // actual points, but we should assume we're not, as per
1643     // the normal sizing case.
1644     m_canvas->Snap(&x, &y);
1645
1646     // Move point
1647     ppt->m_polygonVertex->x = x - this->GetX();
1648     ppt->m_polygonVertex->y = y - this->GetY();
1649     ppt->SetX(x);
1650     ppt->SetY(y);
1651     ((wxPolygonShape *)this)->CalculateBoundingBox();
1652     ((wxPolygonShape *)this)->CalculatePolygonCentre();
1653   }
1654   #else
1655   {
1656     ppt->CalculateNewSize(x, y);
1657   }
1658   #endif
1659
1660   this->GetEventHandler()->OnDrawOutline(dc, this->GetX(), this->GetY(),
1661        ppt->GetNewSize().x, ppt->GetNewSize().y);
1662 }
1663
1664 void wxPolygonShape::OnSizingBeginDragLeft(wxControlPoint* pt, double x, double y, int WXUNUSED(keys), int WXUNUSED(attachment))
1665 {
1666   wxPolygonControlPoint* ppt = (wxPolygonControlPoint*) pt;
1667
1668   wxClientDC dc(GetCanvas());
1669   GetCanvas()->PrepareDC(dc);
1670
1671   this->Erase(dc);
1672
1673   dc.SetLogicalFunction(OGLRBLF);
1674
1675   double bound_x;
1676   double bound_y;
1677   this->GetBoundingBoxMin(&bound_x, &bound_y);
1678
1679   double dist = (double)sqrt((x - this->GetX())*(x - this->GetX()) +
1680                     (y - this->GetY())*(y - this->GetY()));
1681   ppt->m_originalDistance = dist;
1682   ppt->m_originalSize.x = bound_x;
1683   ppt->m_originalSize.y = bound_y;
1684
1685   if (ppt->m_originalDistance == 0.0) ppt->m_originalDistance = (double) 0.0001;
1686
1687   wxPen dottedPen(wxColour(0, 0, 0), 1, wxDOT);
1688   dc.SetPen(dottedPen);
1689   dc.SetBrush((* wxTRANSPARENT_BRUSH));
1690
1691   #if 0 // keys & KEY_CTRL)
1692   {
1693     // TODO: mend this code. Currently we rely on altering the
1694     // actual points, but we should assume we're not, as per
1695     // the normal sizing case.
1696     m_canvas->Snap(&x, &y);
1697
1698     // Move point
1699     ppt->m_polygonVertex->x = x - this->GetX();
1700     ppt->m_polygonVertex->y = y - this->GetY();
1701     ppt->SetX(x);
1702     ppt->SetY(y);
1703     ((wxPolygonShape *)this)->CalculateBoundingBox();
1704     ((wxPolygonShape *)this)->CalculatePolygonCentre();
1705   }
1706   #else
1707   {
1708     ppt->CalculateNewSize(x, y);
1709   }
1710   #endif
1711
1712   this->GetEventHandler()->OnDrawOutline(dc, this->GetX(), this->GetY(),
1713        ppt->GetNewSize().x, ppt->GetNewSize().y);
1714
1715   m_canvas->CaptureMouse();
1716 }
1717
1718 void wxPolygonShape::OnSizingEndDragLeft(wxControlPoint* pt, double WXUNUSED(x), double WXUNUSED(y), int keys, int WXUNUSED(attachment))
1719 {
1720   wxPolygonControlPoint* ppt = (wxPolygonControlPoint*) pt;
1721
1722   wxClientDC dc(GetCanvas());
1723   GetCanvas()->PrepareDC(dc);
1724
1725   m_canvas->ReleaseMouse();
1726   dc.SetLogicalFunction(wxCOPY);
1727
1728   // If we're changing shape, must reset the original points
1729   if (keys & KEY_CTRL)
1730   {
1731     ((wxPolygonShape *)this)->CalculateBoundingBox();
1732     ((wxPolygonShape *)this)->UpdateOriginalPoints();
1733   }
1734   else
1735   {
1736     SetSize(ppt->GetNewSize().x, ppt->GetNewSize().y);
1737   }
1738
1739   ((wxPolygonShape *)this)->CalculateBoundingBox();
1740   ((wxPolygonShape *)this)->CalculatePolygonCentre();
1741
1742   this->Recompute();
1743   this->ResetControlPoints();
1744   this->Move(dc, this->GetX(), this->GetY());
1745   if (!m_canvas->GetQuickEditMode()) m_canvas->Redraw(dc);
1746 }
1747
1748 /*
1749  * Object region
1750  *
1751  */
1752 IMPLEMENT_DYNAMIC_CLASS(wxShapeRegion, wxObject)
1753
1754 wxShapeRegion::wxShapeRegion()
1755 {
1756   m_regionText = wxEmptyString;
1757   m_font = g_oglNormalFont;
1758   m_minHeight = 5.0;
1759   m_minWidth = 5.0;
1760   m_width = 0.0;
1761   m_height = 0.0;
1762   m_x = 0.0;
1763   m_y = 0.0;
1764
1765   m_regionProportionX = -1.0;
1766   m_regionProportionY = -1.0;
1767   m_formatMode = FORMAT_CENTRE_HORIZ | FORMAT_CENTRE_VERT;
1768   m_regionName = wxEmptyString;
1769   m_textColour = wxT("BLACK");
1770   m_penColour = wxT("BLACK");
1771   m_penStyle = wxSOLID;
1772   m_actualColourObject = NULL;
1773   m_actualPenObject = NULL;
1774 }
1775
1776 wxShapeRegion::wxShapeRegion(wxShapeRegion& region)
1777 {
1778   m_regionText = region.m_regionText;
1779   m_regionName = region.m_regionName;
1780   m_textColour = region.m_textColour;
1781
1782   m_font = region.m_font;
1783   m_minHeight = region.m_minHeight;
1784   m_minWidth = region.m_minWidth;
1785   m_width = region.m_width;
1786   m_height = region.m_height;
1787   m_x = region.m_x;
1788   m_y = region.m_y;
1789
1790   m_regionProportionX = region.m_regionProportionX;
1791   m_regionProportionY = region.m_regionProportionY;
1792   m_formatMode = region.m_formatMode;
1793   m_actualColourObject = NULL;
1794   m_actualPenObject = NULL;
1795   m_penStyle = region.m_penStyle;
1796   m_penColour = region.m_penColour;
1797
1798   ClearText();
1799   wxNode *node = region.m_formattedText.GetFirst();
1800   while (node)
1801   {
1802     wxShapeTextLine *line = (wxShapeTextLine *)node->GetData();
1803     wxShapeTextLine *new_line =
1804       new wxShapeTextLine(line->GetX(), line->GetY(), line->GetText());
1805     m_formattedText.Append(new_line);
1806     node = node->GetNext();
1807   }
1808 }
1809
1810 wxShapeRegion::~wxShapeRegion()
1811 {
1812   ClearText();
1813 }
1814
1815 void wxShapeRegion::ClearText()
1816 {
1817   wxNode *node = m_formattedText.GetFirst();
1818   while (node)
1819   {
1820     wxShapeTextLine *line = (wxShapeTextLine *)node->GetData();
1821     wxNode *next = node->GetNext();
1822     delete line;
1823     delete node;
1824     node = next;
1825   }
1826 }
1827
1828 void wxShapeRegion::SetFont(wxFont *f)
1829 {
1830   m_font = f;
1831 }
1832
1833 void wxShapeRegion::SetMinSize(double w, double h)
1834 {
1835   m_minWidth = w;
1836   m_minHeight = h;
1837 }
1838
1839 void wxShapeRegion::SetSize(double w, double h)
1840 {
1841   m_width = w;
1842   m_height = h;
1843 }
1844
1845 void wxShapeRegion::SetPosition(double xp, double yp)
1846 {
1847   m_x = xp;
1848   m_y = yp;
1849 }
1850
1851 void wxShapeRegion::SetProportions(double xp, double yp)
1852 {
1853   m_regionProportionX = xp;
1854   m_regionProportionY = yp;
1855 }
1856
1857 void wxShapeRegion::SetFormatMode(int mode)
1858 {
1859   m_formatMode = mode;
1860 }
1861
1862 void wxShapeRegion::SetColour(const wxString& col)
1863 {
1864   m_textColour = col;
1865   m_actualColourObject = NULL;
1866 }
1867
1868 wxColour *wxShapeRegion::GetActualColourObject()
1869 {
1870   if (!m_actualColourObject)
1871     m_actualColourObject = wxTheColourDatabase->FindColour(GetColour());
1872   if (!m_actualColourObject)
1873     m_actualColourObject = wxBLACK;
1874   return m_actualColourObject;
1875 }
1876
1877 void wxShapeRegion::SetPenColour(const wxString& col)
1878 {
1879   m_penColour = col;
1880   m_actualPenObject = NULL;
1881 }
1882
1883 // Returns NULL if the pen is invisible
1884 // (different to pen being transparent; indicates that
1885 // region boundary should not be drawn.)
1886 wxPen *wxShapeRegion::GetActualPen()
1887 {
1888   if (m_actualPenObject)
1889     return m_actualPenObject;
1890
1891   if (!m_penColour) return NULL;
1892   if (m_penColour == wxT("Invisible"))
1893     return NULL;
1894   m_actualPenObject = wxThePenList->FindOrCreatePen(m_penColour, 1, m_penStyle);
1895   return m_actualPenObject;
1896 }
1897
1898