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