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 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 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 x1, double 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& 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 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         break;
1179       }
1180     }
1181     return TRUE;
1182   }
1183   else
1184   { *x = m_xpos; *y = m_ypos; return TRUE; }
1185 }
1186
1187
1188 // Circle object
1189 IMPLEMENT_DYNAMIC_CLASS(wxCircleShape, wxEllipseShape)
1190
1191 wxCircleShape::wxCircleShape(double diameter):wxEllipseShape(diameter, diameter)
1192 {
1193     SetMaintainAspectRatio(TRUE);
1194 }
1195
1196 void wxCircleShape::Copy(wxShape& copy)
1197 {
1198   wxEllipseShape::Copy(copy);
1199 }
1200
1201 bool wxCircleShape::GetPerimeterPoint(double x1, double y1,
1202                                       double x2, double y2,
1203                                       double *x3, double *y3)
1204 {
1205   oglFindEndForCircle(m_width/2,
1206                       m_xpos, m_ypos,  // Centre of circle
1207                       x2, y2,  // Other end of line
1208                       x3, y3);
1209
1210   return TRUE;
1211 }
1212
1213 // Control points
1214
1215 double wxControlPoint::sm_controlPointDragStartX = 0.0;
1216 double wxControlPoint::sm_controlPointDragStartY = 0.0;
1217 double wxControlPoint::sm_controlPointDragStartWidth = 0.0;
1218 double wxControlPoint::sm_controlPointDragStartHeight = 0.0;
1219 double wxControlPoint::sm_controlPointDragEndWidth = 0.0;
1220 double wxControlPoint::sm_controlPointDragEndHeight = 0.0;
1221 double wxControlPoint::sm_controlPointDragPosX = 0.0;
1222 double wxControlPoint::sm_controlPointDragPosY = 0.0;
1223
1224 IMPLEMENT_DYNAMIC_CLASS(wxControlPoint, wxRectangleShape)
1225
1226 wxControlPoint::wxControlPoint(wxShapeCanvas *theCanvas, wxShape *object, double size, double the_xoffset, double the_yoffset, int the_type):wxRectangleShape(size, size)
1227 {
1228   m_canvas = theCanvas;
1229   m_shape = object;
1230   m_xoffset = the_xoffset;
1231   m_yoffset = the_yoffset;
1232   m_type = the_type;
1233   SetPen(g_oglBlackForegroundPen);
1234   SetBrush(wxBLACK_BRUSH);
1235   m_oldCursor = NULL;
1236   m_visible = TRUE;
1237   m_eraseObject = TRUE;
1238 }
1239
1240 wxControlPoint::~wxControlPoint()
1241 {
1242 }
1243
1244 // Don't even attempt to draw any text - waste of time!
1245 void wxControlPoint::OnDrawContents(wxDC& dc)
1246 {
1247 }
1248
1249 void wxControlPoint::OnDraw(wxDC& dc)
1250 {
1251   m_xpos = m_shape->GetX() + m_xoffset;
1252   m_ypos = m_shape->GetY() + m_yoffset;
1253   wxRectangleShape::OnDraw(dc);
1254 }
1255
1256 void wxControlPoint::OnErase(wxDC& dc)
1257 {
1258   wxRectangleShape::OnErase(dc);
1259 }
1260
1261 // Implement resizing of canvas object
1262 void wxControlPoint::OnDragLeft(bool draw, double x, double y, int keys, int attachment)
1263 {
1264     m_shape->GetEventHandler()->OnSizingDragLeft(this, draw, x, y, keys, attachment);
1265 }
1266
1267 void wxControlPoint::OnBeginDragLeft(double x, double y, int keys, int attachment)
1268 {
1269     m_shape->GetEventHandler()->OnSizingBeginDragLeft(this, x, y, keys, attachment);
1270 }
1271
1272 void wxControlPoint::OnEndDragLeft(double x, double y, int keys, int attachment)
1273 {
1274     m_shape->GetEventHandler()->OnSizingEndDragLeft(this, x, y, keys, attachment);
1275 }
1276
1277 int wxControlPoint::GetNumberOfAttachments() const
1278 {
1279   return 1;
1280 }
1281
1282 bool wxControlPoint::GetAttachmentPosition(int attachment, double *x, double *y,
1283                                          int nth, int no_arcs, wxLineShape *line)
1284 {
1285   *x = m_xpos; *y = m_ypos;
1286   return TRUE;
1287 }
1288
1289 // Control points ('handles') redirect control to the actual shape, to make it easier
1290 // to override sizing behaviour.
1291 void wxShape::OnSizingDragLeft(wxControlPoint* pt, bool draw, double x, double y, int keys, int attachment)
1292 {
1293   double bound_x;
1294   double bound_y;
1295   this->GetBoundingBoxMin(&bound_x, &bound_y);
1296
1297   wxClientDC dc(GetCanvas());
1298   GetCanvas()->PrepareDC(dc);
1299
1300   dc.SetLogicalFunction(OGLRBLF);
1301
1302   wxPen dottedPen(wxColour(0, 0, 0), 1, wxDOT);
1303   dc.SetPen(dottedPen);
1304   dc.SetBrush((* wxTRANSPARENT_BRUSH));
1305
1306   if (this->GetCentreResize())
1307   {
1308     // Maintain the same centre point.
1309     double new_width = (double)(2.0*fabs(x - this->GetX()));
1310     double new_height = (double)(2.0*fabs(y - this->GetY()));
1311
1312     // Constrain sizing according to what control point you're dragging
1313     if (pt->m_type == CONTROL_POINT_HORIZONTAL)
1314     {
1315         if (GetMaintainAspectRatio())
1316         {
1317             new_height = bound_y*(new_width/bound_x);
1318         }
1319         else
1320             new_height = bound_y;
1321     }
1322     else if (pt->m_type == CONTROL_POINT_VERTICAL)
1323     {
1324         if (GetMaintainAspectRatio())
1325         {
1326             new_width = bound_x*(new_height/bound_y);
1327         }
1328         else
1329             new_width = bound_x;
1330     }
1331     else if (pt->m_type == CONTROL_POINT_DIAGONAL && (keys & KEY_SHIFT))
1332       new_height = bound_y*(new_width/bound_x);
1333
1334     if (this->GetFixedWidth())
1335       new_width = bound_x;
1336
1337     if (this->GetFixedHeight())
1338       new_height = bound_y;
1339
1340     pt->sm_controlPointDragEndWidth = new_width;
1341     pt->sm_controlPointDragEndHeight = new_height;
1342
1343     this->GetEventHandler()->OnDrawOutline(dc, this->GetX(), this->GetY(),
1344                                 new_width, new_height);
1345   }
1346   else
1347   {
1348     // Don't maintain the same centre point!
1349     double newX1 = wxMin(pt->sm_controlPointDragStartX, x);
1350     double newY1 = wxMin(pt->sm_controlPointDragStartY, y);
1351     double newX2 = wxMax(pt->sm_controlPointDragStartX, x);
1352     double newY2 = wxMax(pt->sm_controlPointDragStartY, y);
1353     if (pt->m_type == CONTROL_POINT_HORIZONTAL)
1354     {
1355       newY1 = pt->sm_controlPointDragStartY;
1356       newY2 = newY1 + pt->sm_controlPointDragStartHeight;
1357     }
1358     else if (pt->m_type == CONTROL_POINT_VERTICAL)
1359     {
1360       newX1 = pt->sm_controlPointDragStartX;
1361       newX2 = newX1 + pt->sm_controlPointDragStartWidth;
1362     }
1363     else if (pt->m_type == CONTROL_POINT_DIAGONAL && ((keys & KEY_SHIFT) || GetMaintainAspectRatio()))
1364     {
1365       double newH = (double)((newX2 - newX1)*(pt->sm_controlPointDragStartHeight/pt->sm_controlPointDragStartWidth));
1366       if (GetY() > pt->sm_controlPointDragStartY)
1367         newY2 = (double)(newY1 + newH);
1368       else
1369         newY1 = (double)(newY2 - newH);
1370     }
1371     double newWidth = (double)(newX2 - newX1);
1372     double newHeight = (double)(newY2 - newY1);
1373
1374     if (pt->m_type == CONTROL_POINT_VERTICAL && GetMaintainAspectRatio())
1375     {
1376         newWidth = bound_x * (newHeight/bound_y) ;
1377     }
1378
1379     if (pt->m_type == CONTROL_POINT_HORIZONTAL && GetMaintainAspectRatio())
1380     {
1381         newHeight = bound_y * (newWidth/bound_x) ;
1382     }
1383
1384     pt->sm_controlPointDragPosX = (double)(newX1 + (newWidth/2.0));
1385     pt->sm_controlPointDragPosY = (double)(newY1 + (newHeight/2.0));
1386     if (this->GetFixedWidth())
1387       newWidth = bound_x;
1388
1389     if (this->GetFixedHeight())
1390       newHeight = bound_y;
1391
1392     pt->sm_controlPointDragEndWidth = newWidth;
1393     pt->sm_controlPointDragEndHeight = newHeight;
1394     this->GetEventHandler()->OnDrawOutline(dc, pt->sm_controlPointDragPosX, pt->sm_controlPointDragPosY, newWidth, newHeight);
1395   }
1396 }
1397
1398 void wxShape::OnSizingBeginDragLeft(wxControlPoint* pt, double x, double y, int keys, int attachment)
1399 {
1400   m_canvas->CaptureMouse();
1401
1402   wxClientDC dc(GetCanvas());
1403   GetCanvas()->PrepareDC(dc);
1404 /*
1405   if (pt->m_eraseObject)
1406     this->Erase(dc);
1407 */
1408
1409   dc.SetLogicalFunction(OGLRBLF);
1410
1411   double bound_x;
1412   double bound_y;
1413   this->GetBoundingBoxMin(&bound_x, &bound_y);
1414
1415   // Choose the 'opposite corner' of the object as the stationary
1416   // point in case this is non-centring resizing.
1417   if (pt->GetX() < this->GetX())
1418     pt->sm_controlPointDragStartX = (double)(this->GetX() + (bound_x/2.0));
1419   else
1420     pt->sm_controlPointDragStartX = (double)(this->GetX() - (bound_x/2.0));
1421
1422   if (pt->GetY() < this->GetY())
1423     pt->sm_controlPointDragStartY = (double)(this->GetY() + (bound_y/2.0));
1424   else
1425     pt->sm_controlPointDragStartY = (double)(this->GetY() - (bound_y/2.0));
1426
1427   if (pt->m_type == CONTROL_POINT_HORIZONTAL)
1428     pt->sm_controlPointDragStartY = (double)(this->GetY() - (bound_y/2.0));
1429   else if (pt->m_type == CONTROL_POINT_VERTICAL)
1430     pt->sm_controlPointDragStartX = (double)(this->GetX() - (bound_x/2.0));
1431
1432   // We may require the old width and height.
1433   pt->sm_controlPointDragStartWidth = bound_x;
1434   pt->sm_controlPointDragStartHeight = bound_y;
1435
1436   wxPen dottedPen(wxColour(0, 0, 0), 1, wxDOT);
1437   dc.SetPen(dottedPen);
1438   dc.SetBrush((* wxTRANSPARENT_BRUSH));
1439
1440   if (this->GetCentreResize())
1441   {
1442     double new_width = (double)(2.0*fabs(x - this->GetX()));
1443     double new_height = (double)(2.0*fabs(y - this->GetY()));
1444
1445     // Constrain sizing according to what control point you're dragging
1446     if (pt->m_type == CONTROL_POINT_HORIZONTAL)
1447     {
1448         if (GetMaintainAspectRatio())
1449         {
1450             new_height = bound_y*(new_width/bound_x);
1451         }
1452         else
1453             new_height = bound_y;
1454     }
1455     else if (pt->m_type == CONTROL_POINT_VERTICAL)
1456     {
1457         if (GetMaintainAspectRatio())
1458         {
1459             new_width = bound_x*(new_height/bound_y);
1460         }
1461         else
1462             new_width = bound_x;
1463     }
1464     else if (pt->m_type == CONTROL_POINT_DIAGONAL && (keys & KEY_SHIFT))
1465       new_height = bound_y*(new_width/bound_x);
1466
1467     if (this->GetFixedWidth())
1468       new_width = bound_x;
1469
1470     if (this->GetFixedHeight())
1471       new_height = bound_y;
1472
1473     pt->sm_controlPointDragEndWidth = new_width;
1474     pt->sm_controlPointDragEndHeight = new_height;
1475     this->GetEventHandler()->OnDrawOutline(dc, this->GetX(), this->GetY(),
1476                                 new_width, new_height);
1477   }
1478   else
1479   {
1480     // Don't maintain the same centre point!
1481     double newX1 = wxMin(pt->sm_controlPointDragStartX, x);
1482     double newY1 = wxMin(pt->sm_controlPointDragStartY, y);
1483     double newX2 = wxMax(pt->sm_controlPointDragStartX, x);
1484     double newY2 = wxMax(pt->sm_controlPointDragStartY, y);
1485     if (pt->m_type == CONTROL_POINT_HORIZONTAL)
1486     {
1487       newY1 = pt->sm_controlPointDragStartY;
1488       newY2 = newY1 + pt->sm_controlPointDragStartHeight;
1489     }
1490     else if (pt->m_type == CONTROL_POINT_VERTICAL)
1491     {
1492       newX1 = pt->sm_controlPointDragStartX;
1493       newX2 = newX1 + pt->sm_controlPointDragStartWidth;
1494     }
1495     else if (pt->m_type == CONTROL_POINT_DIAGONAL && ((keys & KEY_SHIFT) || GetMaintainAspectRatio()))
1496     {
1497       double newH = (double)((newX2 - newX1)*(pt->sm_controlPointDragStartHeight/pt->sm_controlPointDragStartWidth));
1498       if (pt->GetY() > pt->sm_controlPointDragStartY)
1499         newY2 = (double)(newY1 + newH);
1500       else
1501         newY1 = (double)(newY2 - newH);
1502     }
1503     double newWidth = (double)(newX2 - newX1);
1504     double newHeight = (double)(newY2 - newY1);
1505
1506     if (pt->m_type == CONTROL_POINT_VERTICAL && GetMaintainAspectRatio())
1507     {
1508         newWidth = bound_x * (newHeight/bound_y) ;
1509     }
1510
1511     if (pt->m_type == CONTROL_POINT_HORIZONTAL && GetMaintainAspectRatio())
1512     {
1513         newHeight = bound_y * (newWidth/bound_x) ;
1514     }
1515
1516     pt->sm_controlPointDragPosX = (double)(newX1 + (newWidth/2.0));
1517     pt->sm_controlPointDragPosY = (double)(newY1 + (newHeight/2.0));
1518     if (this->GetFixedWidth())
1519       newWidth = bound_x;
1520
1521     if (this->GetFixedHeight())
1522       newHeight = bound_y;
1523
1524     pt->sm_controlPointDragEndWidth = newWidth;
1525     pt->sm_controlPointDragEndHeight = newHeight;
1526     this->GetEventHandler()->OnDrawOutline(dc, pt->sm_controlPointDragPosX, pt->sm_controlPointDragPosY, newWidth, newHeight);
1527   }
1528 }
1529
1530 void wxShape::OnSizingEndDragLeft(wxControlPoint* pt, double x, double y, int keys, int attachment)
1531 {
1532   wxClientDC dc(GetCanvas());
1533   GetCanvas()->PrepareDC(dc);
1534
1535   m_canvas->ReleaseMouse();
1536   dc.SetLogicalFunction(wxCOPY);
1537   this->Recompute();
1538   this->ResetControlPoints();
1539
1540   this->Erase(dc);
1541 /*
1542   if (!pt->m_eraseObject)
1543     this->Show(FALSE);
1544 */
1545
1546   this->SetSize(pt->sm_controlPointDragEndWidth, pt->sm_controlPointDragEndHeight);
1547
1548   // The next operation could destroy this control point (it does for label objects,
1549   // via formatting the text), so save all values we're going to use, or
1550   // we'll be accessing garbage.
1551   wxShape *theObject = this;
1552   wxShapeCanvas *theCanvas = m_canvas;
1553   bool eraseIt = pt->m_eraseObject;
1554
1555   if (theObject->GetCentreResize())
1556     theObject->Move(dc, theObject->GetX(), theObject->GetY());
1557   else
1558     theObject->Move(dc, pt->sm_controlPointDragPosX, pt->sm_controlPointDragPosY);
1559
1560 /*
1561   if (!eraseIt)
1562     theObject->Show(TRUE);
1563 */
1564
1565   // Recursively redraw links if we have a composite.
1566   if (theObject->GetChildren().GetCount() > 0)
1567     theObject->DrawLinks(dc, -1, TRUE);
1568
1569   double width, height;
1570   theObject->GetBoundingBoxMax(&width, &height);
1571   theObject->GetEventHandler()->OnEndSize(width, height);
1572
1573   if (!theCanvas->GetQuickEditMode() && eraseIt) theCanvas->Redraw(dc);
1574 }
1575
1576
1577
1578 // Polygon control points
1579
1580 IMPLEMENT_DYNAMIC_CLASS(wxPolygonControlPoint, wxControlPoint)
1581
1582 wxPolygonControlPoint::wxPolygonControlPoint(wxShapeCanvas *theCanvas, wxShape *object, double size,
1583   wxRealPoint *vertex, double the_xoffset, double the_yoffset):
1584   wxControlPoint(theCanvas, object, size, the_xoffset, the_yoffset, 0)
1585 {
1586   m_polygonVertex = vertex;
1587   m_originalDistance = 0.0;
1588 }
1589
1590 wxPolygonControlPoint::~wxPolygonControlPoint()
1591 {
1592 }
1593
1594 // Calculate what new size would be, at end of resize
1595 void wxPolygonControlPoint::CalculateNewSize(double x, double y)
1596 {
1597   double bound_x;
1598   double bound_y;
1599   GetShape()->GetBoundingBoxMin(&bound_x, &bound_y);
1600
1601   double dist = (double)sqrt((x - m_shape->GetX())*(x - m_shape->GetX()) +
1602                     (y - m_shape->GetY())*(y - m_shape->GetY()));
1603
1604   m_newSize.x = (double)(dist/this->m_originalDistance)*this->m_originalSize.x;
1605   m_newSize.y = (double)(dist/this->m_originalDistance)*this->m_originalSize.y;
1606 }
1607
1608
1609 // Implement resizing polygon or moving the vertex.
1610 void wxPolygonControlPoint::OnDragLeft(bool draw, double x, double y, int keys, int attachment)
1611 {
1612     m_shape->GetEventHandler()->OnSizingDragLeft(this, draw, x, y, keys, attachment);
1613 }
1614
1615 void wxPolygonControlPoint::OnBeginDragLeft(double x, double y, int keys, int attachment)
1616 {
1617     m_shape->GetEventHandler()->OnSizingBeginDragLeft(this, x, y, keys, attachment);
1618 }
1619
1620 void wxPolygonControlPoint::OnEndDragLeft(double x, double y, int keys, int attachment)
1621 {
1622     m_shape->GetEventHandler()->OnSizingEndDragLeft(this, x, y, keys, attachment);
1623 }
1624
1625 // Control points ('handles') redirect control to the actual shape, to make it easier
1626 // to override sizing behaviour.
1627 void wxPolygonShape::OnSizingDragLeft(wxControlPoint* pt, bool draw, double x, double y, int keys, int attachment)
1628 {
1629   wxPolygonControlPoint* ppt = (wxPolygonControlPoint*) pt;
1630
1631   wxClientDC dc(GetCanvas());
1632   GetCanvas()->PrepareDC(dc);
1633
1634   dc.SetLogicalFunction(OGLRBLF);
1635
1636   wxPen dottedPen(wxColour(0, 0, 0), 1, wxDOT);
1637   dc.SetPen(dottedPen);
1638   dc.SetBrush((* wxTRANSPARENT_BRUSH));
1639
1640   if (0) // keys & KEY_CTRL)
1641   {
1642     // TODO: mend this code. Currently we rely on altering the
1643     // actual points, but we should assume we're not, as per
1644     // the normal sizing case.
1645     m_canvas->Snap(&x, &y);
1646
1647     // Move point
1648     ppt->m_polygonVertex->x = x - this->GetX();
1649     ppt->m_polygonVertex->y = y - this->GetY();
1650     ppt->SetX(x);
1651     ppt->SetY(y);
1652     ((wxPolygonShape *)this)->CalculateBoundingBox();
1653     ((wxPolygonShape *)this)->CalculatePolygonCentre();
1654   }
1655   else
1656   {
1657     ppt->CalculateNewSize(x, y);
1658   }
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 keys, int 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
1711   this->GetEventHandler()->OnDrawOutline(dc, this->GetX(), this->GetY(),
1712        ppt->GetNewSize().x, ppt->GetNewSize().y);
1713
1714   m_canvas->CaptureMouse();
1715 }
1716
1717 void wxPolygonShape::OnSizingEndDragLeft(wxControlPoint* pt, double x, double y, int keys, int attachment)
1718 {
1719   wxPolygonControlPoint* ppt = (wxPolygonControlPoint*) pt;
1720
1721   wxClientDC dc(GetCanvas());
1722   GetCanvas()->PrepareDC(dc);
1723
1724   m_canvas->ReleaseMouse();
1725   dc.SetLogicalFunction(wxCOPY);
1726
1727   // If we're changing shape, must reset the original points
1728   if (keys & KEY_CTRL)
1729   {
1730     ((wxPolygonShape *)this)->CalculateBoundingBox();
1731     ((wxPolygonShape *)this)->UpdateOriginalPoints();
1732   }
1733   else
1734   {
1735     SetSize(ppt->GetNewSize().x, ppt->GetNewSize().y);
1736   }
1737
1738   ((wxPolygonShape *)this)->CalculateBoundingBox();
1739   ((wxPolygonShape *)this)->CalculatePolygonCentre();
1740
1741   this->Recompute();
1742   this->ResetControlPoints();
1743   this->Move(dc, this->GetX(), this->GetY());
1744   if (!m_canvas->GetQuickEditMode()) m_canvas->Redraw(dc);
1745 }
1746
1747 /*
1748  * Object region
1749  *
1750  */
1751 IMPLEMENT_DYNAMIC_CLASS(wxShapeRegion, wxObject)
1752
1753 wxShapeRegion::wxShapeRegion()
1754 {
1755   m_regionText = wxEmptyString;
1756   m_font = g_oglNormalFont;
1757   m_minHeight = 5.0;
1758   m_minWidth = 5.0;
1759   m_width = 0.0;
1760   m_height = 0.0;
1761   m_x = 0.0;
1762   m_y = 0.0;
1763
1764   m_regionProportionX = -1.0;
1765   m_regionProportionY = -1.0;
1766   m_formatMode = FORMAT_CENTRE_HORIZ | FORMAT_CENTRE_VERT;
1767   m_regionName = wxEmptyString;
1768   m_textColour = wxT("BLACK");
1769   m_penColour = wxT("BLACK");
1770   m_penStyle = wxSOLID;
1771   m_actualColourObject = NULL;
1772   m_actualPenObject = NULL;
1773 }
1774
1775 wxShapeRegion::wxShapeRegion(wxShapeRegion& region)
1776 {
1777   m_regionText = region.m_regionText;
1778   m_regionName = region.m_regionName;
1779   m_textColour = region.m_textColour;
1780
1781   m_font = region.m_font;
1782   m_minHeight = region.m_minHeight;
1783   m_minWidth = region.m_minWidth;
1784   m_width = region.m_width;
1785   m_height = region.m_height;
1786   m_x = region.m_x;
1787   m_y = region.m_y;
1788
1789   m_regionProportionX = region.m_regionProportionX;
1790   m_regionProportionY = region.m_regionProportionY;
1791   m_formatMode = region.m_formatMode;
1792   m_actualColourObject = NULL;
1793   m_actualPenObject = NULL;
1794   m_penStyle = region.m_penStyle;
1795   m_penColour = region.m_penColour;
1796
1797   ClearText();
1798   wxNode *node = region.m_formattedText.GetFirst();
1799   while (node)
1800   {
1801     wxShapeTextLine *line = (wxShapeTextLine *)node->GetData();
1802     wxShapeTextLine *new_line =
1803       new wxShapeTextLine(line->GetX(), line->GetY(), line->GetText());
1804     m_formattedText.Append(new_line);
1805     node = node->GetNext();
1806   }
1807 }
1808
1809 wxShapeRegion::~wxShapeRegion()
1810 {
1811   ClearText();
1812 }
1813
1814 void wxShapeRegion::ClearText()
1815 {
1816   wxNode *node = m_formattedText.GetFirst();
1817   while (node)
1818   {
1819     wxShapeTextLine *line = (wxShapeTextLine *)node->GetData();
1820     wxNode *next = node->GetNext();
1821     delete line;
1822     delete node;
1823     node = next;
1824   }
1825 }
1826
1827 void wxShapeRegion::SetFont(wxFont *f)
1828 {
1829   m_font = f;
1830 }
1831
1832 void wxShapeRegion::SetMinSize(double w, double h)
1833 {
1834   m_minWidth = w;
1835   m_minHeight = h;
1836 }
1837
1838 void wxShapeRegion::SetSize(double w, double h)
1839 {
1840   m_width = w;
1841   m_height = h;
1842 }
1843
1844 void wxShapeRegion::SetPosition(double xp, double yp)
1845 {
1846   m_x = xp;
1847   m_y = yp;
1848 }
1849
1850 void wxShapeRegion::SetProportions(double xp, double yp)
1851 {
1852   m_regionProportionX = xp;
1853   m_regionProportionY = yp;
1854 }
1855
1856 void wxShapeRegion::SetFormatMode(int mode)
1857 {
1858   m_formatMode = mode;
1859 }
1860
1861 void wxShapeRegion::SetColour(const wxString& col)
1862 {
1863   m_textColour = col;
1864   m_actualColourObject = NULL;
1865 }
1866
1867 wxColour *wxShapeRegion::GetActualColourObject()
1868 {
1869   if (!m_actualColourObject)
1870     m_actualColourObject = wxTheColourDatabase->FindColour(GetColour());
1871   if (!m_actualColourObject)
1872     m_actualColourObject = wxBLACK;
1873   return m_actualColourObject;
1874 }
1875
1876 void wxShapeRegion::SetPenColour(const wxString& col)
1877 {
1878   m_penColour = col;
1879   m_actualPenObject = NULL;
1880 }
1881
1882 // Returns NULL if the pen is invisible
1883 // (different to pen being transparent; indicates that
1884 // region boundary should not be drawn.)
1885 wxPen *wxShapeRegion::GetActualPen()
1886 {
1887   if (m_actualPenObject)
1888     return m_actualPenObject;
1889
1890   if (!m_penColour) return NULL;
1891   if (m_penColour == wxT("Invisible"))
1892     return NULL;
1893   m_actualPenObject = wxThePenList->FindOrCreatePen(m_penColour, 1, m_penStyle);
1894   return m_actualPenObject;
1895 }
1896
1897