contrib/src/ogl/lines.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        lines.cpp
   3 // Purpose:     wxLineShape
   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 "lines.h"
  14 #pragma implementation "linesp.h"
  15 #endif
  16
  17 // For compilers that support precompilation, includes "wx.h".
  18 #include "wx/wxprec.h"
  19
  20 #ifdef __BORLANDC__
  21 #pragma hdrstop
  22 #endif
  23
  24 #ifndef WX_PRECOMP
  25 #include <wx/wx.h>
  26 #endif
  27
  28 #if wxUSE_DEPRECATED
  29 #include <wx/deprecated/wxexpr.h>
  30 #endif
  31
  32 #ifdef new
  33 #undef new
  34 #endif
  35
  36 #include <ctype.h>
  37 #include <math.h>
  38
  39 #include <wx/ogl/basic.h>
  40 #include <wx/ogl/basicp.h>
  41 #include <wx/ogl/lines.h>
  42 #include <wx/ogl/linesp.h>
  43 #include <wx/ogl/drawn.h>
  44 #include <wx/ogl/misc.h>
  45 #include <wx/ogl/canvas.h>
  46
  47 // Line shape
  48 IMPLEMENT_DYNAMIC_CLASS(wxLineShape, wxShape)
  49
  50 wxLineShape::wxLineShape()
  51 {
  52   m_sensitivity = OP_CLICK_LEFT | OP_CLICK_RIGHT;
  53   m_draggable = FALSE;
  54   m_attachmentTo = 0;
  55   m_attachmentFrom = 0;
  56 /*
  57   m_actualTextWidth = 0.0;
  58   m_actualTextHeight = 0.0;
  59 */
  60   m_from = NULL;
  61   m_to = NULL;
  62   m_erasing = FALSE;
  63   m_arrowSpacing = 5.0; // For the moment, don't bother saving this to file.
  64   m_ignoreArrowOffsets = FALSE;
  65   m_isSpline = FALSE;
  66   m_maintainStraightLines = FALSE;
  67   m_alignmentStart = 0;
  68   m_alignmentEnd = 0;
  69
  70   m_lineControlPoints = NULL;
  71
  72   // Clear any existing regions (created in an earlier constructor)
  73   // and make the three line regions.
  74   ClearRegions();
  75   wxShapeRegion *newRegion = new wxShapeRegion;
  76   newRegion->SetName(wxT("Middle"));
  77   newRegion->SetSize(150, 50);
  78   m_regions.Append((wxObject *)newRegion);
  79
  80   newRegion = new wxShapeRegion;
  81   newRegion->SetName(wxT("Start"));
  82   newRegion->SetSize(150, 50);
  83   m_regions.Append((wxObject *)newRegion);
  84
  85   newRegion = new wxShapeRegion;
  86   newRegion->SetName(wxT("End"));
  87   newRegion->SetSize(150, 50);
  88   m_regions.Append((wxObject *)newRegion);
  89
  90   for (int i = 0; i < 3; i++)
  91     m_labelObjects[i] = NULL;
  92 }
  93
  94 wxLineShape::~wxLineShape()
  95 {
  96   if (m_lineControlPoints)
  97   {
  98     ClearPointList(*m_lineControlPoints);
  99     delete m_lineControlPoints;
 100   }
 101   for (int i = 0; i < 3; i++)
 102   {
 103     if (m_labelObjects[i])
 104     {
 105       m_labelObjects[i]->Select(FALSE);
 106       m_labelObjects[i]->RemoveFromCanvas(m_canvas);
 107       delete m_labelObjects[i];
 108       m_labelObjects[i] = NULL;
 109     }
 110   }
 111   ClearArrowsAtPosition(-1);
 112 }
 113
 114 void wxLineShape::MakeLineControlPoints(int n)
 115 {
 116   if (m_lineControlPoints)
 117   {
 118     ClearPointList(*m_lineControlPoints);
 119     delete m_lineControlPoints;
 120   }
 121   m_lineControlPoints = new wxList;
 122
 123   int i = 0;
 124   for (i = 0; i < n; i++)
 125   {
 126     wxRealPoint *point = new wxRealPoint(-999, -999);
 127     m_lineControlPoints->Append((wxObject*) point);
 128   }
 129 }
 130
 131 wxNode *wxLineShape::InsertLineControlPoint(wxDC* dc)
 132 {
 133     if (dc)
 134         Erase(*dc);
 135
 136   wxNode *last = m_lineControlPoints->GetLast();
 137   wxNode *second_last = last->GetPrevious();
 138   wxRealPoint *last_point = (wxRealPoint *)last->GetData();
 139   wxRealPoint *second_last_point = (wxRealPoint *)second_last->GetData();
 140
 141   // Choose a point half way between the last and penultimate points
 142   double line_x = ((last_point->x + second_last_point->x)/2);
 143   double line_y = ((last_point->y + second_last_point->y)/2);
 144
 145   wxRealPoint *point = new wxRealPoint(line_x, line_y);
 146   wxNode *node = m_lineControlPoints->Insert(last, (wxObject*) point);
 147   return node;
 148 }
 149
 150 bool wxLineShape::DeleteLineControlPoint()
 151 {
 152   if (m_lineControlPoints->GetCount() < 3)
 153     return FALSE;
 154
 155   wxNode *last = m_lineControlPoints->GetLast();
 156   wxNode *second_last = last->GetPrevious();
 157
 158   wxRealPoint *second_last_point = (wxRealPoint *)second_last->GetData();
 159   delete second_last_point;
 160   delete second_last;
 161
 162   return TRUE;
 163 }
 164
 165 void wxLineShape::Initialise()
 166 {
 167   if (m_lineControlPoints)
 168   {
 169     // Just move the first and last control points
 170     wxNode *first = m_lineControlPoints->GetFirst();
 171     wxRealPoint *first_point = (wxRealPoint *)first->GetData();
 172
 173     wxNode *last = m_lineControlPoints->GetLast();
 174     wxRealPoint *last_point = (wxRealPoint *)last->GetData();
 175
 176     // If any of the line points are at -999, we must
 177     // initialize them by placing them half way between the first
 178     // and the last.
 179     wxNode *node = first->GetNext();
 180     while (node)
 181     {
 182       wxRealPoint *point = (wxRealPoint *)node->GetData();
 183       if (point->x == -999)
 184       {
 185         double x1, y1, x2, y2;
 186         if (first_point->x < last_point->x)
 187           { x1 = first_point->x; x2 = last_point->x; }
 188         else
 189           { x2 = first_point->x; x1 = last_point->x; }
 190
 191         if (first_point->y < last_point->y)
 192           { y1 = first_point->y; y2 = last_point->y; }
 193         else
 194           { y2 = first_point->y; y1 = last_point->y; }
 195
 196         point->x = ((x2 - x1)/2 + x1);
 197         point->y = ((y2 - y1)/2 + y1);
 198       }
 199       node = node->GetNext();
 200     }
 201   }
 202 }
 203
 204 // Format a text string according to the region size, adding
 205 // strings with positions to region text list
 206 void wxLineShape::FormatText(wxDC& dc, const wxString& s, int i)
 207 {
 208   double w, h;
 209   ClearText(i);
 210
 211   if (m_regions.GetCount() < 1)
 212     return;
 213   wxNode *node = m_regions.Item(i);
 214   if (!node)
 215     return;
 216
 217   wxShapeRegion *region = (wxShapeRegion *)node->GetData();
 218   region->SetText(s);
 219   dc.SetFont(* region->GetFont());
 220
 221   region->GetSize(&w, &h);
 222   // Initialize the size if zero
 223   if (((w == 0) || (h == 0)) && (s.Length() > 0))
 224   {
 225     w = 100; h = 50;
 226     region->SetSize(w, h);
 227   }
 228
 229   wxStringList *string_list = oglFormatText(dc, s, (w-5), (h-5), region->GetFormatMode());
 230   node = (wxNode*)string_list->GetFirst();
 231   while (node)
 232   {
 233     wxChar *s = (wxChar *)node->GetData();
 234     wxShapeTextLine *line = new wxShapeTextLine(0.0, 0.0, s);
 235     region->GetFormattedText().Append((wxObject *)line);
 236     node = node->GetNext();
 237   }
 238   delete string_list;
 239   double actualW = w;
 240   double actualH = h;
 241   if (region->GetFormatMode() & FORMAT_SIZE_TO_CONTENTS)
 242   {
 243     oglGetCentredTextExtent(dc, &(region->GetFormattedText()), m_xpos, m_ypos, w, h, &actualW, &actualH);
 244     if ((actualW != w ) || (actualH != h))
 245     {
 246       double xx, yy;
 247       GetLabelPosition(i, &xx, &yy);
 248       EraseRegion(dc, region, xx, yy);
 249       if (m_labelObjects[i])
 250       {
 251         m_labelObjects[i]->Select(FALSE, &dc);
 252         m_labelObjects[i]->Erase(dc);
 253         m_labelObjects[i]->SetSize(actualW, actualH);
 254       }
 255
 256       region->SetSize(actualW, actualH);
 257
 258       if (m_labelObjects[i])
 259       {
 260         m_labelObjects[i]->Select(TRUE, & dc);
 261         m_labelObjects[i]->Draw(dc);
 262       }
 263     }
 264   }
 265   oglCentreText(dc, &(region->GetFormattedText()), m_xpos, m_ypos, actualW, actualH, region->GetFormatMode());
 266   m_formatted = TRUE;
 267 }
 268
 269 void wxLineShape::DrawRegion(wxDC& dc, wxShapeRegion *region, double x, double y)
 270 {
 271   if (GetDisableLabel())
 272     return;
 273
 274   double w, h;
 275   double xx, yy;
 276   region->GetSize(&w, &h);
 277
 278   // Get offset from x, y
 279   region->GetPosition(&xx, &yy);
 280
 281   double xp = xx + x;
 282   double yp = yy + y;
 283
 284   // First, clear a rectangle for the text IF there is any
 285   if (region->GetFormattedText().GetCount() > 0)
 286   {
 287       dc.SetPen(GetBackgroundPen());
 288       dc.SetBrush(GetBackgroundBrush());
 289
 290       // Now draw the text
 291       if (region->GetFont()) dc.SetFont(* region->GetFont());
 292
 293       dc.DrawRectangle((long)(xp - w/2.0), (long)(yp - h/2.0), (long)w, (long)h);
 294
 295       if (m_pen) dc.SetPen(* m_pen);
 296       dc.SetTextForeground(* region->GetActualColourObject());
 297
 298 #ifdef __WXMSW__
 299       dc.SetTextBackground(GetBackgroundBrush().GetColour());
 300 #endif
 301
 302       oglDrawFormattedText(dc, &(region->GetFormattedText()), xp, yp, w, h, region->GetFormatMode());
 303   }
 304 }
 305
 306 void wxLineShape::EraseRegion(wxDC& dc, wxShapeRegion *region, double x, double y)
 307 {
 308   if (GetDisableLabel())
 309     return;
 310
 311   double w, h;
 312   double xx, yy;
 313   region->GetSize(&w, &h);
 314
 315   // Get offset from x, y
 316   region->GetPosition(&xx, &yy);
 317
 318   double xp = xx + x;
 319   double yp = yy + y;
 320
 321   if (region->GetFormattedText().GetCount() > 0)
 322   {
 323       dc.SetPen(GetBackgroundPen());
 324       dc.SetBrush(GetBackgroundBrush());
 325
 326       dc.DrawRectangle((long)(xp - w/2.0), (long)(yp - h/2.0), (long)w, (long)h);
 327   }
 328 }
 329
 330 // Get the reference point for a label. Region x and y
 331 // are offsets from this.
 332 // position is 0, 1, 2
 333 void wxLineShape::GetLabelPosition(int position, double *x, double *y)
 334 {
 335   switch (position)
 336   {
 337     case 0:
 338     {
 339       // Want to take the middle section for the label
 340       int n = m_lineControlPoints->GetCount();
 341       int half_way = (int)(n/2);
 342
 343       // Find middle of this line
 344       wxNode *node = m_lineControlPoints->Item(half_way - 1);
 345       wxRealPoint *point = (wxRealPoint *)node->GetData();
 346       wxNode *next_node = node->GetNext();
 347       wxRealPoint *next_point = (wxRealPoint *)next_node->GetData();
 348
 349       double dx = (next_point->x - point->x);
 350       double dy = (next_point->y - point->y);
 351       *x = (double)(point->x + dx/2.0);
 352       *y = (double)(point->y + dy/2.0);
 353       break;
 354     }
 355     case 1:
 356     {
 357       wxNode *node = m_lineControlPoints->GetFirst();
 358       *x = ((wxRealPoint *)node->GetData())->x;
 359       *y = ((wxRealPoint *)node->GetData())->y;
 360       break;
 361     }
 362     case 2:
 363     {
 364       wxNode *node = m_lineControlPoints->GetLast();
 365       *x = ((wxRealPoint *)node->GetData())->x;
 366       *y = ((wxRealPoint *)node->GetData())->y;
 367       break;
 368     }
 369     default:
 370       break;
 371   }
 372 }
 373
 374 /*
 375  * Find whether line is supposed to be vertical or horizontal and
 376  * make it so.
 377  *
 378  */
 379 void GraphicsStraightenLine(wxRealPoint *point1, wxRealPoint *point2)
 380 {
 381   double dx = point2->x - point1->x;
 382   double dy = point2->y - point1->y;
 383
 384   if (dx == 0.0)
 385     return;
 386   else if (fabs(dy/dx) > 1.0)
 387   {
 388     point2->x = point1->x;
 389   }
 390   else point2->y = point1->y;
 391 }
 392
 393 void wxLineShape::Straighten(wxDC *dc)
 394 {
 395   if (!m_lineControlPoints || m_lineControlPoints->GetCount() < 3)
 396     return;
 397
 398   if (dc)
 399     Erase(* dc);
 400
 401   wxNode *first_point_node = m_lineControlPoints->GetFirst();
 402   wxNode *last_point_node = m_lineControlPoints->GetLast();
 403   wxNode *second_last_point_node = last_point_node->GetPrevious();
 404
 405   wxRealPoint *last_point = (wxRealPoint *)last_point_node->GetData();
 406   wxRealPoint *second_last_point = (wxRealPoint *)second_last_point_node->GetData();
 407
 408   GraphicsStraightenLine(last_point, second_last_point);
 409
 410   wxNode *node = first_point_node;
 411   while (node && (node != second_last_point_node))
 412   {
 413     wxRealPoint *point = (wxRealPoint *)node->GetData();
 414     wxRealPoint *next_point = (wxRealPoint *)(node->GetNext()->GetData());
 415
 416     GraphicsStraightenLine(point, next_point);
 417     node = node->GetNext();
 418   }
 419
 420   if (dc)
 421     Draw(* dc);
 422 }
 423
 424
 425 void wxLineShape::Unlink()
 426 {
 427   if (m_to)
 428     m_to->GetLines().DeleteObject(this);
 429   if (m_from)
 430     m_from->GetLines().DeleteObject(this);
 431   m_to = NULL;
 432   m_from = NULL;
 433 }
 434
 435 void wxLineShape::SetEnds(double x1, double y1, double x2, double y2)
 436 {
 437   // Find centre point
 438   wxNode *first_point_node = m_lineControlPoints->GetFirst();
 439   wxNode *last_point_node = m_lineControlPoints->GetLast();
 440   wxRealPoint *first_point = (wxRealPoint *)first_point_node->GetData();
 441   wxRealPoint *last_point = (wxRealPoint *)last_point_node->GetData();
 442
 443   first_point->x = x1;
 444   first_point->y = y1;
 445   last_point->x = x2;
 446   last_point->y = y2;
 447
 448   m_xpos = (double)((x1 + x2)/2.0);
 449   m_ypos = (double)((y1 + y2)/2.0);
 450 }
 451
 452 // Get absolute positions of ends
 453 void wxLineShape::GetEnds(double *x1, double *y1, double *x2, double *y2)
 454 {
 455   wxNode *first_point_node = m_lineControlPoints->GetFirst();
 456   wxNode *last_point_node = m_lineControlPoints->GetLast();
 457   wxRealPoint *first_point = (wxRealPoint *)first_point_node->GetData();
 458   wxRealPoint *last_point = (wxRealPoint *)last_point_node->GetData();
 459
 460   *x1 = first_point->x; *y1 = first_point->y;
 461   *x2 = last_point->x; *y2 = last_point->y;
 462 }
 463
 464 void wxLineShape::SetAttachments(int from_attach, int to_attach)
 465 {
 466   m_attachmentFrom = from_attach;
 467   m_attachmentTo = to_attach;
 468 }
 469
 470 bool wxLineShape::HitTest(double x, double y, int *attachment, double *distance)
 471 {
 472   if (!m_lineControlPoints)
 473     return FALSE;
 474
 475   // Look at label regions in case mouse is over a label
 476   bool inLabelRegion = FALSE;
 477   for (int i = 0; i < 3; i ++)
 478   {
 479     wxNode *regionNode = m_regions.Item(i);
 480     if (regionNode)
 481     {
 482       wxShapeRegion *region = (wxShapeRegion *)regionNode->GetData();
 483       if (region->m_formattedText.GetCount() > 0)
 484       {
 485         double xp, yp, cx, cy, cw, ch;
 486         GetLabelPosition(i, &xp, &yp);
 487         // Offset region from default label position
 488         region->GetPosition(&cx, &cy);
 489         region->GetSize(&cw, &ch);
 490         cx += xp;
 491         cy += yp;
 492         double rLeft = (double)(cx - (cw/2.0));
 493         double rTop = (double)(cy - (ch/2.0));
 494         double rRight = (double)(cx + (cw/2.0));
 495         double rBottom = (double)(cy + (ch/2.0));
 496         if (x > rLeft && x < rRight && y > rTop && y < rBottom)
 497         {
 498           inLabelRegion = TRUE;
 499           i = 3;
 500         }
 501       }
 502     }
 503   }
 504
 505   wxNode *node = m_lineControlPoints->GetFirst();
 506
 507   while (node && node->GetNext())
 508   {
 509     wxRealPoint *point1 = (wxRealPoint *)node->GetData();
 510     wxRealPoint *point2 = (wxRealPoint *)node->GetNext()->GetData();
 511
 512     // For inaccurate mousing allow 8 pixel corridor
 513     int extra = 4;
 514
 515     double dx = point2->x - point1->x;
 516     double dy = point2->y - point1->y;
 517     double seg_len = sqrt(dx*dx+dy*dy);
 518     double distance_from_seg =
 519       seg_len*((x-point1->x)*dy-(y-point1->y)*dx)/(dy*dy+dx*dx);
 520     double distance_from_prev =
 521       seg_len*((y-point1->y)*dy+(x-point1->x)*dx)/(dy*dy+dx*dx);
 522
 523     if ((fabs(distance_from_seg) < extra &&
 524          distance_from_prev >= 0 && distance_from_prev <= seg_len)
 525         || inLabelRegion)
 526     {
 527       *attachment = 0;
 528       *distance = distance_from_seg;
 529       return TRUE;
 530     }
 531
 532     node = node->GetNext();
 533   }
 534   return FALSE;
 535 }
 536
 537 void wxLineShape::DrawArrows(wxDC& dc)
 538 {
 539   // Distance along line of each arrow: space them out evenly.
 540   double startArrowPos = 0.0;
 541   double endArrowPos = 0.0;
 542   double middleArrowPos = 0.0;
 543
 544   wxNode *node = m_arcArrows.GetFirst();
 545   while (node)
 546   {
 547     wxArrowHead *arrow = (wxArrowHead *)node->GetData();
 548     switch (arrow->GetArrowEnd())
 549     {
 550       case ARROW_POSITION_START:
 551       {
 552         if ((arrow->GetXOffset() != 0.0) && !m_ignoreArrowOffsets)
 553           // If specified, x offset is proportional to line length
 554           DrawArrow(dc, arrow, arrow->GetXOffset(), TRUE);
 555         else
 556         {
 557           DrawArrow(dc, arrow, startArrowPos, FALSE);      // Absolute distance
 558           startArrowPos += arrow->GetSize() + arrow->GetSpacing();
 559         }
 560         break;
 561       }
 562       case ARROW_POSITION_END:
 563       {
 564         if ((arrow->GetXOffset() != 0.0) && !m_ignoreArrowOffsets)
 565           DrawArrow(dc, arrow, arrow->GetXOffset(), TRUE);
 566         else
 567         {
 568           DrawArrow(dc, arrow, endArrowPos, FALSE);
 569           endArrowPos += arrow->GetSize() + arrow->GetSpacing();
 570         }
 571         break;
 572       }
 573       case ARROW_POSITION_MIDDLE:
 574       {
 575         arrow->SetXOffset(middleArrowPos);
 576         if ((arrow->GetXOffset() != 0.0) && !m_ignoreArrowOffsets)
 577           DrawArrow(dc, arrow, arrow->GetXOffset(), TRUE);
 578         else
 579         {
 580           DrawArrow(dc, arrow, middleArrowPos, FALSE);
 581           middleArrowPos += arrow->GetSize() + arrow->GetSpacing();
 582         }
 583         break;
 584       }
 585     }
 586     node = node->GetNext();
 587   }
 588 }
 589
 590 void wxLineShape::DrawArrow(wxDC& dc, wxArrowHead *arrow, double xOffset, bool proportionalOffset)
 591 {
 592   wxNode *first_line_node = m_lineControlPoints->GetFirst();
 593   wxRealPoint *first_line_point = (wxRealPoint *)first_line_node->GetData();
 594   wxNode *second_line_node = first_line_node->GetNext();
 595   wxRealPoint *second_line_point = (wxRealPoint *)second_line_node->GetData();
 596
 597   wxNode *last_line_node = m_lineControlPoints->GetLast();
 598   wxRealPoint *last_line_point = (wxRealPoint *)last_line_node->GetData();
 599   wxNode *second_last_line_node = last_line_node->GetPrevious();
 600   wxRealPoint *second_last_line_point = (wxRealPoint *)second_last_line_node->GetData();
 601
 602   // Position where we want to start drawing
 603   double positionOnLineX, positionOnLineY;
 604
 605   // Position of start point of line, at the end of which we draw the arrow.
 606   double startPositionX, startPositionY;
 607
 608   switch (arrow->GetPosition())
 609   {
 610     case ARROW_POSITION_START:
 611     {
 612       // If we're using a proportional offset, calculate just where this will
 613       // be on the line.
 614       double realOffset = xOffset;
 615       if (proportionalOffset)
 616       {
 617         double totalLength =
 618           (double)sqrt((second_line_point->x - first_line_point->x)*(second_line_point->x - first_line_point->x) +
 619                       (second_line_point->y - first_line_point->y)*(second_line_point->y - first_line_point->y));
 620         realOffset = (double)(xOffset * totalLength);
 621       }
 622       GetPointOnLine(second_line_point->x, second_line_point->y,
 623                      first_line_point->x, first_line_point->y,
 624                      realOffset, &positionOnLineX, &positionOnLineY);
 625       startPositionX = second_line_point->x;
 626       startPositionY = second_line_point->y;
 627       break;
 628     }
 629     case ARROW_POSITION_END:
 630     {
 631       // If we're using a proportional offset, calculate just where this will
 632       // be on the line.
 633       double realOffset = xOffset;
 634       if (proportionalOffset)
 635       {
 636         double totalLength =
 637           (double)sqrt((second_last_line_point->x - last_line_point->x)*(second_last_line_point->x - last_line_point->x) +
 638                       (second_last_line_point->y - last_line_point->y)*(second_last_line_point->y - last_line_point->y));
 639         realOffset = (double)(xOffset * totalLength);
 640       }
 641       GetPointOnLine(second_last_line_point->x, second_last_line_point->y,
 642                      last_line_point->x, last_line_point->y,
 643                      realOffset, &positionOnLineX, &positionOnLineY);
 644       startPositionX = second_last_line_point->x;
 645       startPositionY = second_last_line_point->y;
 646       break;
 647     }
 648     case ARROW_POSITION_MIDDLE:
 649     {
 650       // Choose a point half way between the last and penultimate points
 651       double x = ((last_line_point->x + second_last_line_point->x)/2);
 652       double y = ((last_line_point->y + second_last_line_point->y)/2);
 653
 654       // If we're using a proportional offset, calculate just where this will
 655       // be on the line.
 656       double realOffset = xOffset;
 657       if (proportionalOffset)
 658       {
 659         double totalLength =
 660           (double)sqrt((second_last_line_point->x - x)*(second_last_line_point->x - x) +
 661                       (second_last_line_point->y - y)*(second_last_line_point->y - y));
 662         realOffset = (double)(xOffset * totalLength);
 663       }
 664
 665       GetPointOnLine(second_last_line_point->x, second_last_line_point->y,
 666                      x, y, realOffset, &positionOnLineX, &positionOnLineY);
 667       startPositionX = second_last_line_point->x;
 668       startPositionY = second_last_line_point->y;
 669       break;
 670     }
 671   }
 672
 673   /*
 674    * Add yOffset to arrow, if any
 675    */
 676
 677   const double myPi = (double) 3.14159265;
 678   // The translation that the y offset may give
 679   double deltaX = 0.0;
 680   double deltaY = 0.0;
 681   if ((arrow->GetYOffset() != 0.0) && !m_ignoreArrowOffsets)
 682   {
 683     /*
 684                                  |(x4, y4)
 685                                  |d
 686                                  |
 687        (x1, y1)--------------(x3, y3)------------------(x2, y2)
 688        x4 = x3 - d * sin(theta)
 689        y4 = y3 + d * cos(theta)
 690
 691        Where theta = tan(-1) of (y3-y1)/(x3-x1)
 692      */
 693      double x1 = startPositionX;
 694      double y1 = startPositionY;
 695      double x3 = positionOnLineX;
 696      double y3 = positionOnLineY;
 697      double d = -arrow->GetYOffset(); // Negate so +offset is above line
 698
 699      double theta = 0.0;
 700      if (x3 == x1)
 701        theta = (double)(myPi/2.0);
 702      else
 703        theta = (double)atan((y3-y1)/(x3-x1));
 704
 705      double x4 = (double)(x3 - (d*sin(theta)));
 706      double y4 = (double)(y3 + (d*cos(theta)));
 707
 708      deltaX = x4 - positionOnLineX;
 709      deltaY = y4 - positionOnLineY;
 710   }
 711
 712   switch (arrow->_GetType())
 713   {
 714     case ARROW_ARROW:
 715     {
 716       double arrowLength = arrow->GetSize();
 717       double arrowWidth = (double)(arrowLength/3.0);
 718
 719       double tip_x, tip_y, side1_x, side1_y, side2_x, side2_y;
 720       oglGetArrowPoints(startPositionX+deltaX, startPositionY+deltaY,
 721                        positionOnLineX+deltaX, positionOnLineY+deltaY,
 722                        arrowLength, arrowWidth, &tip_x, &tip_y,
 723                        &side1_x, &side1_y, &side2_x, &side2_y);
 724
 725       wxPoint points[4];
 726       points[0].x = (int) tip_x; points[0].y = (int) tip_y;
 727       points[1].x = (int) side1_x; points[1].y = (int) side1_y;
 728       points[2].x = (int) side2_x; points[2].y = (int) side2_y;
 729       points[3].x = (int) tip_x; points[3].y = (int) tip_y;
 730
 731       dc.SetPen(* m_pen);
 732       dc.SetBrush(* m_brush);
 733       dc.DrawPolygon(4, points);
 734       break;
 735     }
 736     case ARROW_HOLLOW_CIRCLE:
 737     case ARROW_FILLED_CIRCLE:
 738     {
 739       // Find point on line of centre of circle, which is a radius away
 740       // from the end position
 741       double diameter = (double)(arrow->GetSize());
 742       double x, y;
 743       GetPointOnLine(startPositionX+deltaX, startPositionY+deltaY,
 744                    positionOnLineX+deltaX, positionOnLineY+deltaY,
 745                    (double)(diameter/2.0),
 746                    &x, &y);
 747
 748       // Convert ellipse centre to top-left coordinates
 749       double x1 = (double)(x - (diameter/2.0));
 750       double y1 = (double)(y - (diameter/2.0));
 751
 752       dc.SetPen(* m_pen);
 753       if (arrow->_GetType() == ARROW_HOLLOW_CIRCLE)
 754         dc.SetBrush(* g_oglWhiteBackgroundBrush);
 755       else
 756         dc.SetBrush(* m_brush);
 757
 758       dc.DrawEllipse((long) x1, (long) y1, (long) diameter, (long) diameter);
 759       break;
 760     }
 761     case ARROW_SINGLE_OBLIQUE:
 762     {
 763       break;
 764     }
 765     case ARROW_METAFILE:
 766     {
 767       if (arrow->GetMetaFile())
 768       {
 769         // Find point on line of centre of object, which is a half-width away
 770         // from the end position
 771         /*
 772          *                width
 773          * <-- start pos  <-----><-- positionOnLineX
 774          *                _____
 775          * --------------|  x  | <-- e.g. rectangular arrowhead
 776          *                -----
 777          */
 778         double x, y;
 779         GetPointOnLine(startPositionX, startPositionY,
 780                    positionOnLineX, positionOnLineY,
 781                    (double)(arrow->GetMetaFile()->m_width/2.0),
 782                    &x, &y);
 783
 784         // Calculate theta for rotating the metafile.
 785         /*
 786           |
 787           |     o(x2, y2)   'o' represents the arrowhead.
 788           |    /
 789           |   /
 790           |  /theta
 791           | /(x1, y1)
 792           |______________________
 793         */
 794         double theta = 0.0;
 795         double x1 = startPositionX;
 796         double y1 = startPositionY;
 797         double x2 = positionOnLineX;
 798         double y2 = positionOnLineY;
 799
 800         if ((x1 == x2) && (y1 == y2))
 801           theta = 0.0;
 802
 803         else if ((x1 == x2) && (y1 > y2))
 804           theta = (double)(3.0*myPi/2.0);
 805
 806         else if ((x1 == x2) && (y2 > y1))
 807           theta = (double)(myPi/2.0);
 808
 809         else if ((x2 > x1) && (y2 >= y1))
 810           theta = (double)atan((y2 - y1)/(x2 - x1));
 811
 812         else if (x2 < x1)
 813           theta = (double)(myPi + atan((y2 - y1)/(x2 - x1)));
 814
 815         else if ((x2 > x1) && (y2 < y1))
 816           theta = (double)(2*myPi + atan((y2 - y1)/(x2 - x1)));
 817
 818         else
 819         {
 820           wxLogFatalError(wxT("Unknown arrowhead rotation case in lines.cc"));
 821         }
 822
 823         // Rotate about the centre of the object, then place
 824         // the object on the line.
 825         if (arrow->GetMetaFile()->GetRotateable())
 826           arrow->GetMetaFile()->Rotate(0.0, 0.0, theta);
 827
 828         if (m_erasing)
 829         {
 830           // If erasing, just draw a rectangle.
 831           double minX, minY, maxX, maxY;
 832           arrow->GetMetaFile()->GetBounds(&minX, &minY, &maxX, &maxY);
 833           // Make erasing rectangle slightly bigger or you get droppings.
 834           int extraPixels = 4;
 835           dc.DrawRectangle((long)(deltaX + x + minX - (extraPixels/2.0)), (long)(deltaY + y + minY - (extraPixels/2.0)),
 836                            (long)(maxX - minX + extraPixels), (long)(maxY - minY + extraPixels));
 837         }
 838         else
 839           arrow->GetMetaFile()->Draw(dc, x+deltaX, y+deltaY);
 840       }
 841       break;
 842     }
 843     default:
 844     {
 845     }
 846   }
 847 }
 848
 849 void wxLineShape::OnErase(wxDC& dc)
 850 {
 851     wxPen *old_pen = m_pen;
 852     wxBrush *old_brush = m_brush;
 853     wxPen bg_pen = GetBackgroundPen();
 854     wxBrush bg_brush = GetBackgroundBrush();
 855     SetPen(&bg_pen);
 856     SetBrush(&bg_brush);
 857
 858     double bound_x, bound_y;
 859     GetBoundingBoxMax(&bound_x, &bound_y);
 860     if (m_font) dc.SetFont(* m_font);
 861
 862     // Undraw text regions
 863     for (int i = 0; i < 3; i++)
 864     {
 865       wxNode *node = m_regions.Item(i);
 866       if (node)
 867       {
 868         double x, y;
 869         wxShapeRegion *region = (wxShapeRegion *)node->GetData();
 870         GetLabelPosition(i, &x, &y);
 871         EraseRegion(dc, region, x, y);
 872       }
 873     }
 874
 875     // Undraw line
 876     dc.SetPen(GetBackgroundPen());
 877     dc.SetBrush(GetBackgroundBrush());
 878
 879     // Drawing over the line only seems to work if the line has a thickness
 880     // of 1.
 881     if (old_pen && (old_pen->GetWidth() > 1))
 882     {
 883       dc.DrawRectangle((long)(m_xpos - (bound_x/2.0) - 2.0), (long)(m_ypos - (bound_y/2.0) - 2.0),
 884                         (long)(bound_x+4.0),  (long)(bound_y+4.0));
 885     }
 886     else
 887     {
 888       m_erasing = TRUE;
 889       GetEventHandler()->OnDraw(dc);
 890       GetEventHandler()->OnEraseControlPoints(dc);
 891       m_erasing = FALSE;
 892     }
 893
 894     if (old_pen) SetPen(old_pen);
 895     if (old_brush) SetBrush(old_brush);
 896 }
 897
 898 void wxLineShape::GetBoundingBoxMin(double *w, double *h)
 899 {
 900   double x1 = 10000;
 901   double y1 = 10000;
 902   double x2 = -10000;
 903   double y2 = -10000;
 904
 905   wxNode *node = m_lineControlPoints->GetFirst();
 906   while (node)
 907   {
 908     wxRealPoint *point = (wxRealPoint *)node->GetData();
 909
 910     if (point->x < x1) x1 = point->x;
 911     if (point->y < y1) y1 = point->y;
 912     if (point->x > x2) x2 = point->x;
 913     if (point->y > y2) y2 = point->y;
 914
 915     node = node->GetNext();
 916   }
 917   *w = (double)(x2 - x1);
 918   *h = (double)(y2 - y1);
 919 }
 920
 921 /*
 922  * For a node image of interest, finds the position of this arc
 923  * amongst all the arcs which are attached to THIS SIDE of the node image,
 924  * and the number of same.
 925  */
 926 void wxLineShape::FindNth(wxShape *image, int *nth, int *no_arcs, bool incoming)
 927 {
 928   int n = -1;
 929   int num = 0;
 930   wxNode *node = image->GetLines().GetFirst();
 931   int this_attachment;
 932   if (image == m_to)
 933     this_attachment = m_attachmentTo;
 934   else
 935     this_attachment = m_attachmentFrom;
 936
 937   // Find number of lines going into/out of this particular attachment point
 938   while (node)
 939   {
 940     wxLineShape *line = (wxLineShape *)node->GetData();
 941
 942     if (line->m_from == image)
 943     {
 944       // This is the nth line attached to 'image'
 945       if ((line == this) && !incoming)
 946         n = num;
 947
 948       // Increment num count if this is the same side (attachment number)
 949       if (line->m_attachmentFrom == this_attachment)
 950         num ++;
 951     }
 952
 953     if (line->m_to == image)
 954     {
 955       // This is the nth line attached to 'image'
 956       if ((line == this) && incoming)
 957         n = num;
 958
 959       // Increment num count if this is the same side (attachment number)
 960       if (line->m_attachmentTo == this_attachment)
 961         num ++;
 962     }
 963
 964     node = node->GetNext();
 965   }
 966   *nth = n;
 967   *no_arcs = num;
 968 }
 969
 970 void wxLineShape::OnDrawOutline(wxDC& dc, double x, double y, double w, double h)
 971 {
 972   wxPen *old_pen = m_pen;
 973   wxBrush *old_brush = m_brush;
 974
 975   wxPen dottedPen(wxColour(0, 0, 0), 1, wxDOT);
 976   SetPen(& dottedPen);
 977   SetBrush( wxTRANSPARENT_BRUSH );
 978
 979   GetEventHandler()->OnDraw(dc);
 980
 981   if (old_pen) SetPen(old_pen);
 982   else SetPen(NULL);
 983   if (old_brush) SetBrush(old_brush);
 984   else SetBrush(NULL);
 985 }
 986
 987 bool wxLineShape::OnMovePre(wxDC& dc, double x, double y, double old_x, double old_y, bool display)
 988 {
 989   double x_offset = x - old_x;
 990   double y_offset = y - old_y;
 991
 992   if (m_lineControlPoints && !(x_offset == 0.0 && y_offset == 0.0))
 993   {
 994     wxNode *node = m_lineControlPoints->GetFirst();
 995     while (node)
 996     {
 997       wxRealPoint *point = (wxRealPoint *)node->GetData();
 998       point->x += x_offset;
 999       point->y += y_offset;
1000       node = node->GetNext();
1001     }
1002
1003   }
1004
1005   // Move temporary label rectangles if necessary
1006   for (int i = 0; i < 3; i++)
1007   {
1008     if (m_labelObjects[i])
1009     {
1010       m_labelObjects[i]->Erase(dc);
1011       double xp, yp, xr, yr;
1012       GetLabelPosition(i, &xp, &yp);
1013       wxNode *node = m_regions.Item(i);
1014       if (node)
1015       {
1016         wxShapeRegion *region = (wxShapeRegion *)node->GetData();
1017         region->GetPosition(&xr, &yr);
1018       }
1019       else
1020       {
1021         xr = 0.0; yr = 0.0;
1022       }
1023
1024       m_labelObjects[i]->Move(dc, xp+xr, yp+yr);
1025     }
1026   }
1027   return TRUE;
1028 }
1029
1030 void wxLineShape::OnMoveLink(wxDC& dc, bool moveControlPoints)
1031 {
1032   if (!m_from || !m_to)
1033    return;
1034
1035     if (m_lineControlPoints->GetCount() > 2)
1036       Initialise();
1037
1038     // Do each end - nothing in the middle. User has to move other points
1039     // manually if necessary.
1040     double end_x, end_y;
1041     double other_end_x, other_end_y;
1042
1043     FindLineEndPoints(&end_x, &end_y, &other_end_x, &other_end_y);
1044
1045     wxNode *first = m_lineControlPoints->GetFirst();
1046     wxRealPoint *first_point = (wxRealPoint *)first->GetData();
1047     wxNode *last = m_lineControlPoints->GetLast();
1048     wxRealPoint *last_point = (wxRealPoint *)last->GetData();
1049
1050 /* This is redundant, surely? Done by SetEnds.
1051     first_point->x = end_x; first_point->y = end_y;
1052     last_point->x = other_end_x; last_point->y = other_end_y;
1053 */
1054
1055     double oldX = m_xpos;
1056     double oldY = m_ypos;
1057
1058     SetEnds(end_x, end_y, other_end_x, other_end_y);
1059
1060     // Do a second time, because one may depend on the other.
1061     FindLineEndPoints(&end_x, &end_y, &other_end_x, &other_end_y);
1062     SetEnds(end_x, end_y, other_end_x, other_end_y);
1063
1064     // Try to move control points with the arc
1065     double x_offset = m_xpos - oldX;
1066     double y_offset = m_ypos - oldY;
1067
1068 //    if (moveControlPoints && m_lineControlPoints && !(x_offset == 0.0 && y_offset == 0.0))
1069     // Only move control points if it's a self link. And only works if attachment mode is ON.
1070     if ((m_from == m_to) && (m_from->GetAttachmentMode() != ATTACHMENT_MODE_NONE) && moveControlPoints && m_lineControlPoints && !(x_offset == 0.0 && y_offset == 0.0))
1071     {
1072       wxNode *node = m_lineControlPoints->GetFirst();
1073       while (node)
1074       {
1075         if ((node != m_lineControlPoints->GetFirst()) && (node != m_lineControlPoints->GetLast()))
1076         {
1077           wxRealPoint *point = (wxRealPoint *)node->GetData();
1078           point->x += x_offset;
1079           point->y += y_offset;
1080         }
1081         node = node->GetNext();
1082       }
1083     }
1084
1085     Move(dc, m_xpos, m_ypos);
1086 }
1087
1088 // Finds the x, y points at the two ends of the line.
1089 // This function can be used by e.g. line-routing routines to
1090 // get the actual points on the two node images where the lines will be drawn
1091 // to/from.
1092 void wxLineShape::FindLineEndPoints(double *fromX, double *fromY, double *toX, double *toY)
1093 {
1094   if (!m_from || !m_to)
1095    return;
1096
1097   // Do each end - nothing in the middle. User has to move other points
1098   // manually if necessary.
1099   double end_x, end_y;
1100   double other_end_x, other_end_y;
1101
1102   wxNode *first = m_lineControlPoints->GetFirst();
1103   wxRealPoint *first_point = (wxRealPoint *)first->GetData();
1104   wxNode *last = m_lineControlPoints->GetLast();
1105   wxRealPoint *last_point = (wxRealPoint *)last->GetData();
1106
1107   wxNode *second = first->GetNext();
1108   wxRealPoint *second_point = (wxRealPoint *)second->GetData();
1109
1110   wxNode *second_last = last->GetPrevious();
1111   wxRealPoint *second_last_point = (wxRealPoint *)second_last->GetData();
1112
1113   if (m_lineControlPoints->GetCount() > 2)
1114   {
1115     if (m_from->GetAttachmentMode() != ATTACHMENT_MODE_NONE)
1116     {
1117       int nth, no_arcs;
1118       FindNth(m_from, &nth, &no_arcs, FALSE); // Not incoming
1119       m_from->GetAttachmentPosition(m_attachmentFrom, &end_x, &end_y, nth, no_arcs, this);
1120     }
1121     else
1122       (void) m_from->GetPerimeterPoint(m_from->GetX(), m_from->GetY(),
1123                                    (double)second_point->x, (double)second_point->y,
1124                                     &end_x, &end_y);
1125
1126     if (m_to->GetAttachmentMode() != ATTACHMENT_MODE_NONE)
1127     {
1128       int nth, no_arcs;
1129       FindNth(m_to, &nth, &no_arcs, TRUE); // Incoming
1130       m_to->GetAttachmentPosition(m_attachmentTo, &other_end_x, &other_end_y, nth, no_arcs, this);
1131     }
1132     else
1133       (void) m_to->GetPerimeterPoint(m_to->GetX(), m_to->GetY(),
1134                                 (double)second_last_point->x, (double)second_last_point->y,
1135                                 &other_end_x, &other_end_y);
1136   }
1137   else
1138   {
1139     double fromX = m_from->GetX();
1140     double fromY = m_from->GetY();
1141     double toX = m_to->GetX();
1142     double toY = m_to->GetY();
1143
1144     if (m_from->GetAttachmentMode() != ATTACHMENT_MODE_NONE)
1145     {
1146       int nth, no_arcs;
1147       FindNth(m_from, &nth, &no_arcs, FALSE);
1148       m_from->GetAttachmentPosition(m_attachmentFrom, &end_x, &end_y, nth, no_arcs, this);
1149       fromX = end_x;
1150       fromY = end_y;
1151     }
1152
1153     if (m_to->GetAttachmentMode() != ATTACHMENT_MODE_NONE)
1154     {
1155       int nth, no_arcs;
1156       FindNth(m_to, &nth, &no_arcs, TRUE);
1157       m_to->GetAttachmentPosition(m_attachmentTo, &other_end_x, &other_end_y, nth, no_arcs, this);
1158       toX = other_end_x;
1159       toY = other_end_y;
1160     }
1161
1162     if (m_from->GetAttachmentMode() == ATTACHMENT_MODE_NONE)
1163       (void) m_from->GetPerimeterPoint(m_from->GetX(), m_from->GetY(),
1164                                   toX, toY,
1165                                   &end_x, &end_y);
1166
1167     if (m_to->GetAttachmentMode() == ATTACHMENT_MODE_NONE)
1168       (void) m_to->GetPerimeterPoint(m_to->GetX(), m_to->GetY(),
1169                                 fromX, fromY,
1170                                 &other_end_x, &other_end_y);
1171   }
1172   *fromX = end_x;
1173   *fromY = end_y;
1174   *toX = other_end_x;
1175   *toY = other_end_y;
1176 }
1177
1178 void wxLineShape::OnDraw(wxDC& dc)
1179 {
1180   if (m_lineControlPoints)
1181   {
1182     if (m_pen)
1183       dc.SetPen(* m_pen);
1184     if (m_brush)
1185       dc.SetBrush(* m_brush);
1186
1187     int n = m_lineControlPoints->GetCount();
1188     wxPoint *points = new wxPoint[n];
1189     int i;
1190     for (i = 0; i < n; i++)
1191     {
1192         wxRealPoint* point = (wxRealPoint*) m_lineControlPoints->Item(i)->GetData();
1193         points[i].x = WXROUND(point->x);
1194         points[i].y = WXROUND(point->y);
1195     }
1196
1197     if (m_isSpline)
1198       dc.DrawSpline(n, points);
1199     else
1200       dc.DrawLines(n, points);
1201
1202 #ifdef __WXMSW__
1203     // For some reason, last point isn't drawn under Windows.
1204     dc.DrawPoint(points[n-1]);
1205 #endif
1206
1207     delete[] points;
1208
1209
1210     // Problem with pen - if not a solid pen, does strange things
1211     // to the arrowhead. So make (get) a new pen that's solid.
1212     if (m_pen && (m_pen->GetStyle() != wxSOLID))
1213     {
1214       wxPen *solid_pen =
1215         wxThePenList->FindOrCreatePen(m_pen->GetColour(), 1, wxSOLID);
1216       if (solid_pen)
1217         dc.SetPen(* solid_pen);
1218     }
1219     DrawArrows(dc);
1220   }
1221 }
1222
1223 void wxLineShape::OnDrawControlPoints(wxDC& dc)
1224 {
1225   if (!m_drawHandles)
1226     return;
1227
1228   // Draw temporary label rectangles if necessary
1229   for (int i = 0; i < 3; i++)
1230   {
1231     if (m_labelObjects[i])
1232       m_labelObjects[i]->Draw(dc);
1233   }
1234   wxShape::OnDrawControlPoints(dc);
1235 }
1236
1237 void wxLineShape::OnEraseControlPoints(wxDC& dc)
1238 {
1239   // Erase temporary label rectangles if necessary
1240   for (int i = 0; i < 3; i++)
1241   {
1242     if (m_labelObjects[i])
1243       m_labelObjects[i]->Erase(dc);
1244   }
1245   wxShape::OnEraseControlPoints(dc);
1246 }
1247
1248 void wxLineShape::OnDragLeft(bool draw, double x, double y, int keys, int attachment)
1249 {
1250 }
1251
1252 void wxLineShape::OnBeginDragLeft(double x, double y, int keys, int attachment)
1253 {
1254 }
1255
1256 void wxLineShape::OnEndDragLeft(double x, double y, int keys, int attachment)
1257 {
1258 }
1259
1260 /*
1261 void wxLineShape::SetArrowSize(double length, double width)
1262 {
1263   arrow_length = length;
1264   arrow_width = width;
1265 }
1266
1267 void wxLineShape::SetStartArrow(int style)
1268 {
1269   start_style = style;
1270 }
1271
1272 void wxLineShape::SetMiddleArrow(int style)
1273 {
1274   middle_style = style;
1275 }
1276
1277 void wxLineShape::SetEndArrow(int style)
1278 {
1279   end_style = style;
1280 }
1281 */
1282
1283 void wxLineShape::OnDrawContents(wxDC& dc)
1284 {
1285   if (GetDisableLabel())
1286     return;
1287
1288   for (int i = 0; i < 3; i++)
1289   {
1290     wxNode *node = m_regions.Item(i);
1291     if (node)
1292     {
1293       wxShapeRegion *region = (wxShapeRegion *)node->GetData();
1294       double x, y;
1295       GetLabelPosition(i, &x, &y);
1296       DrawRegion(dc, region, x, y);
1297     }
1298   }
1299 }
1300
1301 void wxLineShape::SetTo(wxShape *object)
1302 {
1303   m_to = object;
1304 }
1305
1306 void wxLineShape::SetFrom(wxShape *object)
1307 {
1308   m_from = object;
1309 }
1310
1311 void wxLineShape::MakeControlPoints()
1312 {
1313   if (m_canvas && m_lineControlPoints)
1314   {
1315     wxNode *first = m_lineControlPoints->GetFirst();
1316     wxNode *last = m_lineControlPoints->GetLast();
1317     wxRealPoint *first_point = (wxRealPoint *)first->GetData();
1318     wxRealPoint *last_point = (wxRealPoint *)last->GetData();
1319
1320     wxLineControlPoint *control = new wxLineControlPoint(m_canvas, this, CONTROL_POINT_SIZE,
1321                                                first_point->x, first_point->y,
1322                                                CONTROL_POINT_ENDPOINT_FROM);
1323     control->m_point = first_point;
1324     m_canvas->AddShape(control);
1325     m_controlPoints.Append(control);
1326
1327
1328     wxNode *node = first->GetNext();
1329     while (node != last)
1330     {
1331       wxRealPoint *point = (wxRealPoint *)node->GetData();
1332
1333       control = new wxLineControlPoint(m_canvas, this, CONTROL_POINT_SIZE,
1334                                                point->x, point->y,
1335                                                CONTROL_POINT_LINE);
1336       control->m_point = point;
1337
1338       m_canvas->AddShape(control);
1339       m_controlPoints.Append(control);
1340
1341       node = node->GetNext();
1342     }
1343     control = new wxLineControlPoint(m_canvas, this, CONTROL_POINT_SIZE,
1344                                                last_point->x, last_point->y,
1345                                                CONTROL_POINT_ENDPOINT_TO);
1346     control->m_point = last_point;
1347     m_canvas->AddShape(control);
1348     m_controlPoints.Append(control);
1349
1350   }
1351
1352 }
1353
1354 void wxLineShape::ResetControlPoints()
1355 {
1356   if (m_canvas && m_lineControlPoints && m_controlPoints.GetCount() > 0)
1357   {
1358     wxNode *node = m_controlPoints.GetFirst();
1359     wxNode *control_node = m_lineControlPoints->GetFirst();
1360     while (node && control_node)
1361     {
1362       wxRealPoint *point = (wxRealPoint *)control_node->GetData();
1363       wxLineControlPoint *control = (wxLineControlPoint *)node->GetData();
1364       control->SetX(point->x);
1365       control->SetY(point->y);
1366
1367       node = node->GetNext();
1368       control_node = control_node->GetNext();
1369     }
1370   }
1371 }
1372
1373 #if wxUSE_PROLOGIO
1374 void wxLineShape::WriteAttributes(wxExpr *clause)
1375 {
1376   wxShape::WriteAttributes(clause);
1377
1378   if (m_from)
1379     clause->AddAttributeValue("from", m_from->GetId());
1380   if (m_to)
1381     clause->AddAttributeValue("to", m_to->GetId());
1382
1383   if (m_attachmentTo != 0)
1384     clause->AddAttributeValue("attachment_to", (long)m_attachmentTo);
1385   if (m_attachmentFrom != 0)
1386     clause->AddAttributeValue("attachment_from", (long)m_attachmentFrom);
1387
1388   if (m_alignmentStart != 0)
1389     clause->AddAttributeValue("align_start", (long)m_alignmentStart);
1390   if (m_alignmentEnd != 0)
1391     clause->AddAttributeValue("align_end", (long)m_alignmentEnd);
1392
1393   clause->AddAttributeValue("is_spline", (long)m_isSpline);
1394   if (m_maintainStraightLines)
1395     clause->AddAttributeValue("keep_lines_straight", (long)m_maintainStraightLines);
1396
1397   // Make a list of lists for the (sp)line controls
1398   wxExpr *list = new wxExpr(wxExprList);
1399   wxNode *node = m_lineControlPoints->GetFirst();
1400   while (node)
1401   {
1402     wxRealPoint *point = (wxRealPoint *)node->GetData();
1403     wxExpr *point_list = new wxExpr(wxExprList);
1404     wxExpr *x_expr = new wxExpr((double) point->x);
1405     wxExpr *y_expr = new wxExpr((double) point->y);
1406     point_list->Append(x_expr);
1407     point_list->Append(y_expr);
1408     list->Append(point_list);
1409
1410     node = node->GetNext();
1411   }
1412   clause->AddAttributeValue("controls", list);
1413
1414   // Write arc arrows in new OGL format, if there are any.
1415   // This is a list of lists. Each sublist comprises:
1416   // (arrowType arrowEnd xOffset arrowSize)
1417   if (m_arcArrows.GetCount() > 0)
1418   {
1419     wxExpr *arrow_list = new wxExpr(wxExprList);
1420     node = m_arcArrows.GetFirst();
1421     while (node)
1422     {
1423       wxArrowHead *head = (wxArrowHead *)node->GetData();
1424       wxExpr *head_list = new wxExpr(wxExprList);
1425       head_list->Append(new wxExpr((long)head->_GetType()));
1426       head_list->Append(new wxExpr((long)head->GetArrowEnd()));
1427       head_list->Append(new wxExpr(head->GetXOffset()));
1428       head_list->Append(new wxExpr(head->GetArrowSize()));
1429       head_list->Append(new wxExpr(wxExprString, head->GetName()));
1430       head_list->Append(new wxExpr(head->GetId()));
1431
1432       // New members of wxArrowHead
1433       head_list->Append(new wxExpr(head->GetYOffset()));
1434       head_list->Append(new wxExpr(head->GetSpacing()));
1435
1436       arrow_list->Append(head_list);
1437
1438       node = node->GetNext();
1439     }
1440     clause->AddAttributeValue("arrows", arrow_list);
1441   }
1442 }
1443
1444 void wxLineShape::ReadAttributes(wxExpr *clause)
1445 {
1446   wxShape::ReadAttributes(clause);
1447
1448   int iVal = (int) m_isSpline;
1449   clause->AssignAttributeValue(wxT("is_spline"), &iVal);
1450   m_isSpline = (iVal != 0);
1451
1452   iVal = (int) m_maintainStraightLines;
1453   clause->AssignAttributeValue(wxT("keep_lines_straight"), &iVal);
1454   m_maintainStraightLines = (iVal != 0);
1455
1456   clause->AssignAttributeValue(wxT("align_start"), &m_alignmentStart);
1457   clause->AssignAttributeValue(wxT("align_end"), &m_alignmentEnd);
1458
1459   // Compatibility: check for no regions.
1460   if (m_regions.GetCount() == 0)
1461   {
1462     wxShapeRegion *newRegion = new wxShapeRegion;
1463     newRegion->SetName("Middle");
1464     newRegion->SetSize(150, 50);
1465     m_regions.Append((wxObject *)newRegion);
1466     if (m_text.GetCount() > 0)
1467     {
1468       newRegion->ClearText();
1469       wxNode *node = m_text.GetFirst();
1470       while (node)
1471       {
1472         wxShapeTextLine *textLine = (wxShapeTextLine *)node->GetData();
1473         wxNode *next = node->GetNext();
1474         newRegion->GetFormattedText().Append((wxObject *)textLine);
1475         delete node;
1476         node = next;
1477       }
1478     }
1479
1480     newRegion = new wxShapeRegion;
1481     newRegion->SetName(wxT("Start"));
1482     newRegion->SetSize(150, 50);
1483     m_regions.Append((wxObject *)newRegion);
1484
1485     newRegion = new wxShapeRegion;
1486     newRegion->SetName(wxT("End"));
1487     newRegion->SetSize(150, 50);
1488     m_regions.Append((wxObject *)newRegion);
1489   }
1490
1491   m_attachmentTo = 0;
1492   m_attachmentFrom = 0;
1493
1494   clause->AssignAttributeValue(wxT("attachment_to"), &m_attachmentTo);
1495   clause->AssignAttributeValue(wxT("attachment_from"), &m_attachmentFrom);
1496
1497   wxExpr *line_list = NULL;
1498
1499   // When image is created, there are default control points. Override
1500   // them if there are some in the file.
1501   clause->AssignAttributeValue(wxT("controls"), &line_list);
1502
1503   if (line_list)
1504   {
1505     // Read a list of lists for the spline controls
1506     if (m_lineControlPoints)
1507     {
1508       ClearPointList(*m_lineControlPoints);
1509     }
1510     else
1511       m_lineControlPoints = new wxList;
1512
1513     wxExpr *node = line_list->value.first;
1514
1515     while (node)
1516     {
1517       wxExpr *xexpr = node->value.first;
1518       double x = xexpr->RealValue();
1519
1520       wxExpr *yexpr = xexpr->next;
1521       double y = yexpr->RealValue();
1522
1523       wxRealPoint *point = new wxRealPoint(x, y);
1524       m_lineControlPoints->Append((wxObject*) point);
1525
1526       node = node->next;
1527     }
1528   }
1529
1530   // Read arrow list, for new OGL code
1531   wxExpr *arrow_list = NULL;
1532
1533   clause->AssignAttributeValue(wxT("arrows"), &arrow_list);
1534   if (arrow_list)
1535   {
1536     wxExpr *node = arrow_list->value.first;
1537
1538     while (node)
1539     {
1540       WXTYPE arrowType = ARROW_ARROW;
1541       int arrowEnd = 0;
1542       double xOffset = 0.0;
1543       double arrowSize = 0.0;
1544       wxString arrowName;
1545       long arrowId = -1;
1546
1547       wxExpr *type_expr = node->Nth(0);
1548       wxExpr *end_expr = node->Nth(1);
1549       wxExpr *dist_expr = node->Nth(2);
1550       wxExpr *size_expr = node->Nth(3);
1551       wxExpr *name_expr = node->Nth(4);
1552       wxExpr *id_expr = node->Nth(5);
1553
1554       // New members of wxArrowHead
1555       wxExpr *yOffsetExpr = node->Nth(6);
1556       wxExpr *spacingExpr = node->Nth(7);
1557
1558       if (type_expr)
1559         arrowType = (int)type_expr->IntegerValue();
1560       if (end_expr)
1561         arrowEnd = (int)end_expr->IntegerValue();
1562       if (dist_expr)
1563         xOffset = dist_expr->RealValue();
1564       if (size_expr)
1565         arrowSize = size_expr->RealValue();
1566       if (name_expr)
1567         arrowName = name_expr->StringValue();
1568       if (id_expr)
1569         arrowId = id_expr->IntegerValue();
1570
1571       if (arrowId == -1)
1572         arrowId = wxNewId();
1573       else
1574         wxRegisterId(arrowId);
1575
1576       wxArrowHead *arrowHead = AddArrow(arrowType, arrowEnd, arrowSize, xOffset, arrowName, NULL, arrowId);
1577       if (yOffsetExpr)
1578         arrowHead->SetYOffset(yOffsetExpr->RealValue());
1579       if (spacingExpr)
1580         arrowHead->SetSpacing(spacingExpr->RealValue());
1581
1582       node = node->next;
1583     }
1584   }
1585 }
1586 #endif
1587
1588 void wxLineShape::Copy(wxShape& copy)
1589 {
1590   wxShape::Copy(copy);
1591
1592   wxASSERT( copy.IsKindOf(CLASSINFO(wxLineShape)) );
1593
1594   wxLineShape& lineCopy = (wxLineShape&) copy;
1595
1596   lineCopy.m_to = m_to;
1597   lineCopy.m_from = m_from;
1598   lineCopy.m_attachmentTo = m_attachmentTo;
1599   lineCopy.m_attachmentFrom = m_attachmentFrom;
1600   lineCopy.m_isSpline = m_isSpline;
1601   lineCopy.m_alignmentStart = m_alignmentStart;
1602   lineCopy.m_alignmentEnd = m_alignmentEnd;
1603   lineCopy.m_maintainStraightLines = m_maintainStraightLines;
1604   lineCopy.m_lineOrientations.Clear();
1605
1606   wxNode *node = m_lineOrientations.GetFirst();
1607   while (node)
1608   {
1609     lineCopy.m_lineOrientations.Append(node->GetData());
1610     node = node->GetNext();
1611   }
1612
1613   if (lineCopy.m_lineControlPoints)
1614   {
1615     ClearPointList(*lineCopy.m_lineControlPoints);
1616     delete lineCopy.m_lineControlPoints;
1617   }
1618
1619   lineCopy.m_lineControlPoints = new wxList;
1620
1621   node = m_lineControlPoints->GetFirst();
1622   while (node)
1623   {
1624     wxRealPoint *point = (wxRealPoint *)node->GetData();
1625     wxRealPoint *new_point = new wxRealPoint(point->x, point->y);
1626     lineCopy.m_lineControlPoints->Append((wxObject*) new_point);
1627     node = node->GetNext();
1628   }
1629
1630   // Copy arrows
1631   lineCopy.ClearArrowsAtPosition(-1);
1632   node = m_arcArrows.GetFirst();
1633   while (node)
1634   {
1635     wxArrowHead *arrow = (wxArrowHead *)node->GetData();
1636     lineCopy.m_arcArrows.Append(new wxArrowHead(*arrow));
1637     node = node->GetNext();
1638   }
1639 }
1640
1641 // Override select, to create/delete temporary label-moving objects
1642 void wxLineShape::Select(bool select, wxDC* dc)
1643 {
1644   wxShape::Select(select, dc);
1645   if (select)
1646   {
1647     for (int i = 0; i < 3; i++)
1648     {
1649       wxNode *node = m_regions.Item(i);
1650       if (node)
1651       {
1652         wxShapeRegion *region = (wxShapeRegion *)node->GetData();
1653         if (region->m_formattedText.GetCount() > 0)
1654         {
1655           double w, h, x, y, xx, yy;
1656           region->GetSize(&w, &h);
1657           region->GetPosition(&x, &y);
1658           GetLabelPosition(i, &xx, &yy);
1659           if (m_labelObjects[i])
1660           {
1661             m_labelObjects[i]->Select(FALSE);
1662             m_labelObjects[i]->RemoveFromCanvas(m_canvas);
1663             delete m_labelObjects[i];
1664           }
1665           m_labelObjects[i] = OnCreateLabelShape(this, region, w, h);
1666           m_labelObjects[i]->AddToCanvas(m_canvas);
1667           m_labelObjects[i]->Show(TRUE);
1668           if (dc)
1669             m_labelObjects[i]->Move(*dc, (double)(x + xx), (double)(y + yy));
1670           m_labelObjects[i]->Select(TRUE, dc);
1671         }
1672       }
1673     }
1674   }
1675   else
1676   {
1677     for (int i = 0; i < 3; i++)
1678     {
1679       if (m_labelObjects[i])
1680       {
1681         m_labelObjects[i]->Select(FALSE, dc);
1682         m_labelObjects[i]->Erase(*dc);
1683         m_labelObjects[i]->RemoveFromCanvas(m_canvas);
1684         delete m_labelObjects[i];
1685         m_labelObjects[i] = NULL;
1686       }
1687     }
1688   }
1689 }
1690
1691 /*
1692  * Line control point
1693  *
1694  */
1695
1696 IMPLEMENT_DYNAMIC_CLASS(wxLineControlPoint, wxControlPoint)
1697
1698 wxLineControlPoint::wxLineControlPoint(wxShapeCanvas *theCanvas, wxShape *object, double size, double x, double y, int the_type):
1699   wxControlPoint(theCanvas, object, size, x, y, the_type)
1700 {
1701   m_xpos = x;
1702   m_ypos = y;
1703   m_type = the_type;
1704   m_point = NULL;
1705 }
1706
1707 wxLineControlPoint::~wxLineControlPoint()
1708 {
1709 }
1710
1711 void wxLineControlPoint::OnDraw(wxDC& dc)
1712 {
1713   wxRectangleShape::OnDraw(dc);
1714 }
1715
1716 // Implement movement of Line point
1717 void wxLineControlPoint::OnDragLeft(bool draw, double x, double y, int keys, int attachment)
1718 {
1719     m_shape->GetEventHandler()->OnSizingDragLeft(this, draw, x, y, keys, attachment);
1720 }
1721
1722 void wxLineControlPoint::OnBeginDragLeft(double x, double y, int keys, int attachment)
1723 {
1724     m_shape->GetEventHandler()->OnSizingBeginDragLeft(this, x, y, keys, attachment);
1725 }
1726
1727 void wxLineControlPoint::OnEndDragLeft(double x, double y, int keys, int attachment)
1728 {
1729     m_shape->GetEventHandler()->OnSizingEndDragLeft(this, x, y, keys, attachment);
1730 }
1731
1732 // Control points ('handles') redirect control to the actual shape, to make it easier
1733 // to override sizing behaviour.
1734 void wxLineShape::OnSizingDragLeft(wxControlPoint* pt, bool draw, double x, double y, int keys, int attachment)
1735 {
1736   wxLineControlPoint* lpt = (wxLineControlPoint*) pt;
1737
1738   wxClientDC dc(GetCanvas());
1739   GetCanvas()->PrepareDC(dc);
1740
1741   dc.SetLogicalFunction(OGLRBLF);
1742
1743   wxPen dottedPen(wxColour(0, 0, 0), 1, wxDOT);
1744   dc.SetPen(dottedPen);
1745   dc.SetBrush((* wxTRANSPARENT_BRUSH));
1746
1747   if (lpt->m_type == CONTROL_POINT_LINE)
1748   {
1749     m_canvas->Snap(&x, &y);
1750
1751     lpt->SetX(x); lpt->SetY(y);
1752     lpt->m_point->x = x; lpt->m_point->y = y;
1753
1754     wxLineShape *lineShape = (wxLineShape *)this;
1755
1756     wxPen *old_pen = lineShape->GetPen();
1757     wxBrush *old_brush = lineShape->GetBrush();
1758
1759     wxPen dottedPen(wxColour(0, 0, 0), 1, wxDOT);
1760     lineShape->SetPen(& dottedPen);
1761     lineShape->SetBrush(wxTRANSPARENT_BRUSH);
1762
1763     lineShape->GetEventHandler()->OnMoveLink(dc, FALSE);
1764
1765     lineShape->SetPen(old_pen);
1766     lineShape->SetBrush(old_brush);
1767   }
1768
1769   if (lpt->m_type == CONTROL_POINT_ENDPOINT_FROM || lpt->m_type == CONTROL_POINT_ENDPOINT_TO)
1770   {
1771 //    lpt->SetX(x); lpt->SetY(y);
1772   }
1773
1774 }
1775
1776 void wxLineShape::OnSizingBeginDragLeft(wxControlPoint* pt, double x, double y, int keys, int attachment)
1777 {
1778   wxLineControlPoint* lpt = (wxLineControlPoint*) pt;
1779
1780   wxClientDC dc(GetCanvas());
1781   GetCanvas()->PrepareDC(dc);
1782
1783   wxLineShape *lineShape = (wxLineShape *)this;
1784   if (lpt->m_type == CONTROL_POINT_LINE)
1785   {
1786     lpt->m_originalPos = * (lpt->m_point);
1787     m_canvas->Snap(&x, &y);
1788
1789     this->Erase(dc);
1790
1791     // Redraw start and end objects because we've left holes
1792     // when erasing the line
1793     lineShape->GetFrom()->OnDraw(dc);
1794     lineShape->GetFrom()->OnDrawContents(dc);
1795     lineShape->GetTo()->OnDraw(dc);
1796     lineShape->GetTo()->OnDrawContents(dc);
1797
1798     this->SetDisableLabel(TRUE);
1799     dc.SetLogicalFunction(OGLRBLF);
1800
1801     lpt->m_xpos = x; lpt->m_ypos = y;
1802     lpt->m_point->x = x; lpt->m_point->y = y;
1803
1804     wxPen *old_pen = lineShape->GetPen();
1805     wxBrush *old_brush = lineShape->GetBrush();
1806
1807     wxPen dottedPen(wxColour(0, 0, 0), 1, wxDOT);
1808     lineShape->SetPen(& dottedPen);
1809     lineShape->SetBrush(wxTRANSPARENT_BRUSH);
1810
1811     lineShape->GetEventHandler()->OnMoveLink(dc, FALSE);
1812
1813     lineShape->SetPen(old_pen);
1814     lineShape->SetBrush(old_brush);
1815   }
1816
1817   if (lpt->m_type == CONTROL_POINT_ENDPOINT_FROM || lpt->m_type == CONTROL_POINT_ENDPOINT_TO)
1818   {
1819     m_canvas->SetCursor(wxCursor(wxCURSOR_BULLSEYE));
1820     lpt->m_oldCursor = wxSTANDARD_CURSOR;
1821   }
1822 }
1823
1824 void wxLineShape::OnSizingEndDragLeft(wxControlPoint* pt, double x, double y, int keys, int attachment)
1825 {
1826   wxLineControlPoint* lpt = (wxLineControlPoint*) pt;
1827
1828   wxClientDC dc(GetCanvas());
1829   GetCanvas()->PrepareDC(dc);
1830
1831   this->SetDisableLabel(FALSE);
1832   wxLineShape *lineShape = (wxLineShape *)this;
1833
1834   if (lpt->m_type == CONTROL_POINT_LINE)
1835   {
1836     m_canvas->Snap(&x, &y);
1837
1838     wxRealPoint pt = wxRealPoint(x, y);
1839
1840     // Move the control point back to where it was;
1841     // MoveControlPoint will move it to the new position
1842     // if it decides it wants. We only moved the position
1843     // during user feedback so we could redraw the line
1844     // as it changed shape.
1845     lpt->m_xpos = lpt->m_originalPos.x; lpt->m_ypos = lpt->m_originalPos.y;
1846     lpt->m_point->x = lpt->m_originalPos.x; lpt->m_point->y = lpt->m_originalPos.y;
1847
1848     OnMoveMiddleControlPoint(dc, lpt, pt);
1849   }
1850   if (lpt->m_type == CONTROL_POINT_ENDPOINT_FROM)
1851   {
1852     if (lpt->m_oldCursor)
1853       m_canvas->SetCursor(* lpt->m_oldCursor);
1854
1855 //    this->Erase(dc);
1856
1857 //    lpt->m_xpos = x; lpt->m_ypos = y;
1858
1859     if (lineShape->GetFrom())
1860     {
1861       lineShape->GetFrom()->MoveLineToNewAttachment(dc, lineShape, x, y);
1862     }
1863   }
1864   if (lpt->m_type == CONTROL_POINT_ENDPOINT_TO)
1865   {
1866     if (lpt->m_oldCursor)
1867       m_canvas->SetCursor(* lpt->m_oldCursor);
1868
1869 //    lpt->m_xpos = x; lpt->m_ypos = y;
1870
1871     if (lineShape->GetTo())
1872     {
1873       lineShape->GetTo()->MoveLineToNewAttachment(dc, lineShape, x, y);
1874     }
1875   }
1876
1877   // Needed?
1878 #if 0
1879   int i = 0;
1880   for (i = 0; i < lineShape->GetLineControlPoints()->GetCount(); i++)
1881     if (((wxRealPoint *)(lineShape->GetLineControlPoints()->Item(i)->GetData())) == lpt->m_point)
1882       break;
1883
1884   // N.B. in OnMoveControlPoint, an event handler in Hardy could have deselected
1885   // the line and therefore deleted 'this'. -> GPF, intermittently.
1886   // So assume at this point that we've been blown away.
1887
1888   lineShape->OnMoveControlPoint(i+1, x, y);
1889 #endif
1890 }
1891
1892 // This is called only when a non-end control point is moved.
1893 bool wxLineShape::OnMoveMiddleControlPoint(wxDC& dc, wxLineControlPoint* lpt, const wxRealPoint& pt)
1894 {
1895     lpt->m_xpos = pt.x; lpt->m_ypos = pt.y;
1896     lpt->m_point->x = pt.x; lpt->m_point->y = pt.y;
1897
1898     GetEventHandler()->OnMoveLink(dc);
1899
1900     return TRUE;
1901 }
1902
1903 // Implement movement of endpoint to a new attachment
1904 // OBSOLETE: done by dragging with the left button.
1905
1906 #if 0
1907 void wxLineControlPoint::OnDragRight(bool draw, double x, double y, int keys, int attachment)
1908 {
1909   if (m_type == CONTROL_POINT_ENDPOINT_FROM || m_type == CONTROL_POINT_ENDPOINT_TO)
1910   {
1911     m_xpos = x; m_ypos = y;
1912   }
1913 }
1914
1915 void wxLineControlPoint::OnBeginDragRight(double x, double y, int keys, int attachment)
1916 {
1917   wxClientDC dc(GetCanvas());
1918   GetCanvas()->PrepareDC(dc);
1919
1920   wxLineShape *lineShape = (wxLineShape *)m_shape;
1921   if (m_type == CONTROL_POINT_ENDPOINT_FROM || m_type == CONTROL_POINT_ENDPOINT_TO)
1922   {
1923     Erase(dc);
1924     lineShape->GetEventHandler()->OnDraw(dc);
1925     if (m_type == CONTROL_POINT_ENDPOINT_FROM)
1926     {
1927       lineShape->GetFrom()->GetEventHandler()->OnDraw(dc);
1928       lineShape->GetFrom()->GetEventHandler()->OnDrawContents(dc);
1929     }
1930     else
1931     {
1932       lineShape->GetTo()->GetEventHandler()->OnDraw(dc);
1933       lineShape->GetTo()->GetEventHandler()->OnDrawContents(dc);
1934     }
1935     m_canvas->SetCursor(wxCursor(wxCURSOR_BULLSEYE));
1936     m_oldCursor = wxSTANDARD_CURSOR;
1937   }
1938 }
1939
1940 void wxLineControlPoint::OnEndDragRight(double x, double y, int keys, int attachment)
1941 {
1942   wxClientDC dc(GetCanvas());
1943   GetCanvas()->PrepareDC(dc);
1944
1945   wxLineShape *lineShape = (wxLineShape *)m_shape;
1946   if (m_type == CONTROL_POINT_ENDPOINT_FROM)
1947   {
1948     if (m_oldCursor)
1949       m_canvas->SetCursor(m_oldCursor);
1950
1951     m_xpos = x; m_ypos = y;
1952
1953     if (lineShape->GetFrom())
1954     {
1955       lineShape->GetFrom()->EraseLinks(dc);
1956
1957       int new_attachment;
1958       double distance;
1959
1960       if (lineShape->GetFrom()->HitTest(x, y, &new_attachment, &distance))
1961         lineShape->SetAttachments(new_attachment, lineShape->GetAttachmentTo());
1962
1963       lineShape->GetFrom()->MoveLinks(dc);
1964     }
1965   }
1966   if (m_type == CONTROL_POINT_ENDPOINT_TO)
1967   {
1968     if (m_oldCursor)
1969       m_canvas->SetCursor(m_oldCursor);
1970     m_shape->Erase(dc);
1971
1972     m_xpos = x; m_ypos = y;
1973
1974     if (lineShape->GetTo())
1975     {
1976       lineShape->GetTo()->EraseLinks(dc);
1977
1978       int new_attachment;
1979       double distance;
1980       if (lineShape->GetTo()->HitTest(x, y, &new_attachment, &distance))
1981         lineShape->SetAttachments(lineShape->GetAttachmentFrom(), new_attachment);
1982
1983       lineShape->GetTo()->MoveLinks(dc);
1984     }
1985   }
1986   int i = 0;
1987   for (i = 0; i < lineShape->GetLineControlPoints()->GetCount(); i++)
1988     if (((wxRealPoint *)(lineShape->GetLineControlPoints()->Item(i)->GetData())) == m_point)
1989       break;
1990   lineShape->OnMoveControlPoint(i+1, x, y);
1991   if (!m_canvas->GetQuickEditMode()) m_canvas->Redraw(dc);
1992 }
1993 #endif
1994
1995 /*
1996  * Get the point on the given line (x1, y1) (x2, y2)
1997  * distance 'length' along from the end,
1998  * returned values in x and y
1999  */
2000
2001 void GetPointOnLine(double x1, double y1, double x2, double y2,
2002                     double length, double *x, double *y)
2003 {
2004   double l = (double)sqrt((x2 - x1)*(x2 - x1) + (y2 - y1)*(y2 - y1));
2005
2006   if (l < 0.01)
2007     l = (double) 0.01;
2008
2009   double i_bar = (x2 - x1)/l;
2010   double j_bar = (y2 - y1)/l;
2011
2012   *x = (- length*i_bar) + x2;
2013   *y = (- length*j_bar) + y2;
2014 }
2015
2016 wxArrowHead *wxLineShape::AddArrow(WXTYPE type, int end, double size, double xOffset,
2017     const wxString& name, wxPseudoMetaFile *mf, long arrowId)
2018 {
2019   wxArrowHead *arrow = new wxArrowHead(type, end, size, xOffset, name, mf, arrowId);
2020   m_arcArrows.Append(arrow);
2021   return arrow;
2022 }
2023
2024 /*
2025  * Add arrowhead at a particular position in the arrowhead list.
2026  */
2027 bool wxLineShape::AddArrowOrdered(wxArrowHead *arrow, wxList& referenceList, int end)
2028 {
2029   wxNode *refNode = referenceList.GetFirst();
2030   wxNode *currNode = m_arcArrows.GetFirst();
2031   wxString targetName(arrow->GetName());
2032   if (!refNode) return FALSE;
2033
2034   // First check whether we need to insert in front of list,
2035   // because this arrowhead is the first in the reference
2036   // list and should therefore be first in the current list.
2037   wxArrowHead *refArrow = (wxArrowHead *)refNode->GetData();
2038   if (refArrow->GetName() == targetName)
2039   {
2040     m_arcArrows.Insert(arrow);
2041     return TRUE;
2042   }
2043
2044   while (refNode && currNode)
2045   {
2046     wxArrowHead *currArrow = (wxArrowHead *)currNode->GetData();
2047     refArrow = (wxArrowHead *)refNode->GetData();
2048
2049     // Matching: advance current arrow pointer
2050     if ((currArrow->GetArrowEnd() == end) &&
2051         (currArrow->GetName() == refArrow->GetName()))
2052     {
2053       currNode = currNode->GetNext(); // Could be NULL now
2054       if (currNode)
2055         currArrow = (wxArrowHead *)currNode->GetData();
2056     }
2057
2058     // Check if we're at the correct position in the
2059     // reference list
2060     if (targetName == refArrow->GetName())
2061     {
2062       if (currNode)
2063         m_arcArrows.Insert(currNode, arrow);
2064       else
2065         m_arcArrows.Append(arrow);
2066       return TRUE;
2067     }
2068     refNode = refNode->GetNext();
2069   }
2070   m_arcArrows.Append(arrow);
2071   return TRUE;
2072 }
2073
2074 void wxLineShape::ClearArrowsAtPosition(int end)
2075 {
2076   wxNode *node = m_arcArrows.GetFirst();
2077   while (node)
2078   {
2079     wxArrowHead *arrow = (wxArrowHead *)node->GetData();
2080     wxNode *next = node->GetNext();
2081     switch (end)
2082     {
2083       case -1:
2084       {
2085         delete arrow;
2086         delete node;
2087         break;
2088       }
2089       case ARROW_POSITION_START:
2090       {
2091         if (arrow->GetArrowEnd() == ARROW_POSITION_START)
2092         {
2093           delete arrow;
2094           delete node;
2095         }
2096         break;
2097       }
2098       case ARROW_POSITION_END:
2099       {
2100         if (arrow->GetArrowEnd() == ARROW_POSITION_END)
2101         {
2102           delete arrow;
2103           delete node;
2104         }
2105         break;
2106       }
2107       case ARROW_POSITION_MIDDLE:
2108       {
2109         if (arrow->GetArrowEnd() == ARROW_POSITION_MIDDLE)
2110         {
2111           delete arrow;
2112           delete node;
2113         }
2114         break;
2115       }
2116     }
2117     node = next;
2118   }
2119 }
2120
2121 bool wxLineShape::ClearArrow(const wxString& name)
2122 {
2123   wxNode *node = m_arcArrows.GetFirst();
2124   while (node)
2125   {
2126     wxArrowHead *arrow = (wxArrowHead *)node->GetData();
2127     if (arrow->GetName() == name)
2128     {
2129       delete arrow;
2130       delete node;
2131       return TRUE;
2132     }
2133     node = node->GetNext();
2134   }
2135   return FALSE;
2136 }
2137
2138 /*
2139  * Finds an arrowhead at the given position (if -1, any position)
2140  *
2141  */
2142
2143 wxArrowHead *wxLineShape::FindArrowHead(int position, const wxString& name)
2144 {
2145   wxNode *node = m_arcArrows.GetFirst();
2146   while (node)
2147   {
2148     wxArrowHead *arrow = (wxArrowHead *)node->GetData();
2149     if (((position == -1) || (position == arrow->GetArrowEnd())) &&
2150         (arrow->GetName() == name))
2151       return arrow;
2152     node = node->GetNext();
2153   }
2154   return NULL;
2155 }
2156
2157 wxArrowHead *wxLineShape::FindArrowHead(long arrowId)
2158 {
2159   wxNode *node = m_arcArrows.GetFirst();
2160   while (node)
2161   {
2162     wxArrowHead *arrow = (wxArrowHead *)node->GetData();
2163     if (arrowId == arrow->GetId())
2164       return arrow;
2165     node = node->GetNext();
2166   }
2167   return NULL;
2168 }
2169
2170 /*
2171  * Deletes an arrowhead at the given position (if -1, any position)
2172  *
2173  */
2174
2175 bool wxLineShape::DeleteArrowHead(int position, const wxString& name)
2176 {
2177   wxNode *node = m_arcArrows.GetFirst();
2178   while (node)
2179   {
2180     wxArrowHead *arrow = (wxArrowHead *)node->GetData();
2181     if (((position == -1) || (position == arrow->GetArrowEnd())) &&
2182         (arrow->GetName() == name))
2183     {
2184       delete arrow;
2185       delete node;
2186       return TRUE;
2187     }
2188     node = node->GetNext();
2189   }
2190   return FALSE;
2191 }
2192
2193 // Overloaded DeleteArrowHead: pass arrowhead id.
2194 bool wxLineShape::DeleteArrowHead(long id)
2195 {
2196   wxNode *node = m_arcArrows.GetFirst();
2197   while (node)
2198   {
2199     wxArrowHead *arrow = (wxArrowHead *)node->GetData();
2200     if (arrow->GetId() == id)
2201     {
2202       delete arrow;
2203       delete node;
2204       return TRUE;
2205     }
2206     node = node->GetNext();
2207   }
2208   return FALSE;
2209 }
2210
2211 /*
2212  * Calculate the minimum width a line
2213  * occupies, for the purposes of drawing lines in tools.
2214  *
2215  */
2216
2217 double wxLineShape::FindMinimumWidth()
2218 {
2219   double minWidth = 0.0;
2220   wxNode *node = m_arcArrows.GetFirst();
2221   while (node)
2222   {
2223     wxArrowHead *arrowHead = (wxArrowHead *)node->GetData();
2224     minWidth += arrowHead->GetSize();
2225     if (node->GetNext())
2226       minWidth += arrowHead->GetSpacing();
2227
2228     node = node->GetNext();
2229   }
2230   // We have ABSOLUTE minimum now. So
2231   // scale it to give it reasonable aesthetics
2232   // when drawing with line.
2233   if (minWidth > 0.0)
2234     minWidth = (double)(minWidth * 1.4);
2235   else
2236     minWidth = 20.0;
2237
2238   SetEnds(0.0, 0.0, minWidth, 0.0);
2239   Initialise();
2240
2241   return minWidth;
2242 }
2243
2244 // Find which position we're talking about at this (x, y).
2245 // Returns ARROW_POSITION_START, ARROW_POSITION_MIDDLE, ARROW_POSITION_END
2246 int wxLineShape::FindLinePosition(double x, double y)
2247 {
2248   double startX, startY, endX, endY;
2249   GetEnds(&startX, &startY, &endX, &endY);
2250
2251   // Find distances from centre, start and end. The smallest wins.
2252   double centreDistance = (double)(sqrt((x - m_xpos)*(x - m_xpos) + (y - m_ypos)*(y - m_ypos)));
2253   double startDistance = (double)(sqrt((x - startX)*(x - startX) + (y - startY)*(y - startY)));
2254   double endDistance = (double)(sqrt((x - endX)*(x - endX) + (y - endY)*(y - endY)));
2255
2256   if (centreDistance < startDistance && centreDistance < endDistance)
2257     return ARROW_POSITION_MIDDLE;
2258   else if (startDistance < endDistance)
2259     return ARROW_POSITION_START;
2260   else
2261     return ARROW_POSITION_END;
2262 }
2263
2264 // Set alignment flags
2265 void wxLineShape::SetAlignmentOrientation(bool isEnd, bool isHoriz)
2266 {
2267   if (isEnd)
2268   {
2269     if (isHoriz && ((m_alignmentEnd & LINE_ALIGNMENT_HORIZ) != LINE_ALIGNMENT_HORIZ))
2270       m_alignmentEnd |= LINE_ALIGNMENT_HORIZ;
2271     else if (!isHoriz && ((m_alignmentEnd & LINE_ALIGNMENT_HORIZ) == LINE_ALIGNMENT_HORIZ))
2272       m_alignmentEnd -= LINE_ALIGNMENT_HORIZ;
2273   }
2274   else
2275   {
2276     if (isHoriz && ((m_alignmentStart & LINE_ALIGNMENT_HORIZ) != LINE_ALIGNMENT_HORIZ))
2277       m_alignmentStart |= LINE_ALIGNMENT_HORIZ;
2278     else if (!isHoriz && ((m_alignmentStart & LINE_ALIGNMENT_HORIZ) == LINE_ALIGNMENT_HORIZ))
2279       m_alignmentStart -= LINE_ALIGNMENT_HORIZ;
2280   }
2281 }
2282
2283 void wxLineShape::SetAlignmentType(bool isEnd, int alignType)
2284 {
2285   if (isEnd)
2286   {
2287     if (alignType == LINE_ALIGNMENT_TO_NEXT_HANDLE)
2288     {
2289       if ((m_alignmentEnd & LINE_ALIGNMENT_TO_NEXT_HANDLE) != LINE_ALIGNMENT_TO_NEXT_HANDLE)
2290         m_alignmentEnd |= LINE_ALIGNMENT_TO_NEXT_HANDLE;
2291     }
2292     else if ((m_alignmentEnd & LINE_ALIGNMENT_TO_NEXT_HANDLE) == LINE_ALIGNMENT_TO_NEXT_HANDLE)
2293       m_alignmentEnd -= LINE_ALIGNMENT_TO_NEXT_HANDLE;
2294   }
2295   else
2296   {
2297     if (alignType == LINE_ALIGNMENT_TO_NEXT_HANDLE)
2298     {
2299       if ((m_alignmentStart & LINE_ALIGNMENT_TO_NEXT_HANDLE) != LINE_ALIGNMENT_TO_NEXT_HANDLE)
2300         m_alignmentStart |= LINE_ALIGNMENT_TO_NEXT_HANDLE;
2301     }
2302     else if ((m_alignmentStart & LINE_ALIGNMENT_TO_NEXT_HANDLE) == LINE_ALIGNMENT_TO_NEXT_HANDLE)
2303       m_alignmentStart -= LINE_ALIGNMENT_TO_NEXT_HANDLE;
2304   }
2305 }
2306
2307 bool wxLineShape::GetAlignmentOrientation(bool isEnd)
2308 {
2309   if (isEnd)
2310     return ((m_alignmentEnd & LINE_ALIGNMENT_HORIZ) == LINE_ALIGNMENT_HORIZ);
2311   else
2312     return ((m_alignmentStart & LINE_ALIGNMENT_HORIZ) == LINE_ALIGNMENT_HORIZ);
2313 }
2314
2315 int wxLineShape::GetAlignmentType(bool isEnd)
2316 {
2317   if (isEnd)
2318     return (m_alignmentEnd & LINE_ALIGNMENT_TO_NEXT_HANDLE);
2319   else
2320     return (m_alignmentStart & LINE_ALIGNMENT_TO_NEXT_HANDLE);
2321 }
2322
2323 wxRealPoint *wxLineShape::GetNextControlPoint(wxShape *nodeObject)
2324 {
2325   int n = m_lineControlPoints->GetCount();
2326   int nn = 0;
2327   if (m_to == nodeObject)
2328   {
2329     // Must be END of line, so we want (n - 1)th control point.
2330     // But indexing ends at n-1, so subtract 2.
2331     nn = n - 2;
2332   }
2333   else nn = 1;
2334   wxNode *node = m_lineControlPoints->Item(nn);
2335   if (node)
2336   {
2337     return (wxRealPoint *)node->GetData();
2338   }
2339   else
2340     return FALSE;
2341 }
2342
2343 /*
2344  * Arrowhead
2345  *
2346  */
2347
2348 IMPLEMENT_DYNAMIC_CLASS(wxArrowHead, wxObject)
2349
2350 wxArrowHead::wxArrowHead(WXTYPE type, int end, double size, double dist, const wxString& name,
2351                      wxPseudoMetaFile *mf, long arrowId)
2352 {
2353   m_arrowType = type; m_arrowEnd = end; m_arrowSize = size;
2354   m_xOffset = dist;
2355   m_yOffset = 0.0;
2356   m_spacing = 5.0;
2357
2358   m_arrowName = name;
2359   m_metaFile = mf;
2360   m_id = arrowId;
2361   if (m_id == -1)
2362     m_id = wxNewId();
2363 }
2364
2365 wxArrowHead::wxArrowHead(wxArrowHead& toCopy)
2366 {
2367   m_arrowType = toCopy.m_arrowType; m_arrowEnd = toCopy.GetArrowEnd();
2368   m_arrowSize = toCopy.m_arrowSize;
2369   m_xOffset = toCopy.m_xOffset;
2370   m_yOffset = toCopy.m_yOffset;
2371   m_spacing = toCopy.m_spacing;
2372   m_arrowName = toCopy.m_arrowName ;
2373   if (toCopy.m_metaFile)
2374     m_metaFile = new wxPseudoMetaFile(*(toCopy.m_metaFile));
2375   else
2376     m_metaFile = NULL;
2377   m_id = wxNewId();
2378 }
2379
2380 wxArrowHead::~wxArrowHead()
2381 {
2382   if (m_metaFile) delete m_metaFile;
2383 }
2384
2385 void wxArrowHead::SetSize(double size)
2386 {
2387   m_arrowSize = size;
2388   if ((m_arrowType == ARROW_METAFILE) && m_metaFile)
2389   {
2390     double oldWidth = m_metaFile->m_width;
2391     if (oldWidth == 0.0)
2392       return;
2393
2394     double scale = (double)(size/oldWidth);
2395     if (scale != 1.0)
2396       m_metaFile->Scale(scale, scale);
2397   }
2398 }
2399
2400 // Can override this to create a different class of label shape
2401 wxLabelShape* wxLineShape::OnCreateLabelShape(wxLineShape *parent, wxShapeRegion *region, double w, double h)
2402 {
2403     return new wxLabelShape(parent, region, w, h);
2404 }
2405
2406 /*
2407  * Label object
2408  *
2409  */
2410
2411 IMPLEMENT_DYNAMIC_CLASS(wxLabelShape, wxRectangleShape)
2412
2413 wxLabelShape::wxLabelShape(wxLineShape *parent, wxShapeRegion *region, double w, double h):wxRectangleShape(w, h)
2414 {
2415   m_lineShape = parent;
2416   m_shapeRegion = region;
2417   SetPen(wxThePenList->FindOrCreatePen(wxColour(0, 0, 0), 1, wxDOT));
2418 }
2419
2420 wxLabelShape::~wxLabelShape()
2421 {
2422 }
2423
2424 void wxLabelShape::OnDraw(wxDC& dc)
2425 {
2426   if (m_lineShape && !m_lineShape->GetDrawHandles())
2427     return;
2428
2429     double x1 = (double)(m_xpos - m_width/2.0);
2430     double y1 = (double)(m_ypos - m_height/2.0);
2431
2432     if (m_pen)
2433     {
2434       if (m_pen->GetWidth() == 0)
2435         dc.SetPen(* g_oglTransparentPen);
2436       else
2437         dc.SetPen(* m_pen);
2438     }
2439     dc.SetBrush(* wxTRANSPARENT_BRUSH);
2440
2441     if (m_cornerRadius > 0.0)
2442       dc.DrawRoundedRectangle(WXROUND(x1), WXROUND(y1), WXROUND(m_width), WXROUND(m_height), m_cornerRadius);
2443     else
2444       dc.DrawRectangle(WXROUND(x1), WXROUND(y1), WXROUND(m_width), WXROUND(m_height));
2445 }
2446
2447 void wxLabelShape::OnDrawContents(wxDC& dc)
2448 {
2449 }
2450
2451 void wxLabelShape::OnDragLeft(bool draw, double x, double y, int keys, int attachment)
2452 {
2453   wxRectangleShape::OnDragLeft(draw, x, y, keys, attachment);
2454 }
2455
2456 void wxLabelShape::OnBeginDragLeft(double x, double y, int keys, int attachment)
2457 {
2458   wxRectangleShape::OnBeginDragLeft(x, y, keys, attachment);
2459 }
2460
2461 void wxLabelShape::OnEndDragLeft(double x, double y, int keys, int attachment)
2462 {
2463   wxRectangleShape::OnEndDragLeft(x, y, keys, attachment);
2464 }
2465
2466 bool wxLabelShape::OnMovePre(wxDC& dc, double x, double y, double old_x, double old_y, bool display)
2467 {
2468     return m_lineShape->OnLabelMovePre(dc, this, x, y, old_x, old_y, display);
2469 }
2470
2471 bool wxLineShape::OnLabelMovePre(wxDC& dc, wxLabelShape* labelShape, double x, double y, double old_x, double old_y, bool display)
2472 {
2473   labelShape->m_shapeRegion->SetSize(labelShape->GetWidth(), labelShape->GetHeight());
2474
2475   // Find position in line's region list
2476   int i = 0;
2477   wxNode *node = GetRegions().GetFirst();
2478   while (node)
2479   {
2480     if (labelShape->m_shapeRegion == (wxShapeRegion *)node->GetData())
2481       node = NULL;
2482     else
2483     {
2484       node = node->GetNext();
2485       i ++;
2486     }
2487   }
2488   double xx, yy;
2489   GetLabelPosition(i, &xx, &yy);
2490   // Set the region's offset, relative to the default position for
2491   // each region.
2492   labelShape->m_shapeRegion->SetPosition((double)(x - xx), (double)(y - yy));
2493
2494   labelShape->SetX(x);
2495   labelShape->SetY(y);
2496
2497   // Need to reformat to fit region.
2498   if (labelShape->m_shapeRegion->GetText())
2499   {
2500
2501     wxString s(labelShape->m_shapeRegion->GetText());
2502     labelShape->FormatText(dc, s, i);
2503     DrawRegion(dc, labelShape->m_shapeRegion, xx, yy);
2504   }
2505   return TRUE;
2506 }
2507
2508 // Divert left and right clicks to line object
2509 void wxLabelShape::OnLeftClick(double x, double y, int keys, int attachment)
2510 {
2511   m_lineShape->GetEventHandler()->OnLeftClick(x, y, keys, attachment);
2512 }
2513
2514 void wxLabelShape::OnRightClick(double x, double y, int keys, int attachment)
2515 {
2516   m_lineShape->GetEventHandler()->OnRightClick(x, y, keys, attachment);
2517 }
2518