contrib/src/ogl/basic.cpp

   1 /////////////////////////////////////////////////////////////////////////////
   2 // Name:        basic.cpp
   3 // Purpose:     Basic OGL classes
   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 "basic.h"
  14 #endif
  15
  16 // For compilers that support precompilation, includes "wx.h".
  17 #include "wx/wxprec.h"
  18
  19 #ifdef __BORLANDC__
  20 #pragma hdrstop
  21 #endif
  22
  23 #ifndef WX_PRECOMP
  24 #include <wx/wx.h>
  25 #endif
  26
  27 #if wxUSE_PROLOGIO
  28 #include <wx/deprecated/wxexpr.h>
  29 #endif
  30
  31 #ifdef new
  32 #undef new
  33 #endif
  34
  35 #include <stdio.h>
  36 #include <ctype.h>
  37
  38 #include "wx/ogl/ogl.h"
  39
  40
  41 // Control point types
  42 // Rectangle and most other shapes
  43 #define CONTROL_POINT_VERTICAL   1
  44 #define CONTROL_POINT_HORIZONTAL 2
  45 #define CONTROL_POINT_DIAGONAL   3
  46
  47 // Line
  48 #define CONTROL_POINT_ENDPOINT_TO 4
  49 #define CONTROL_POINT_ENDPOINT_FROM 5
  50 #define CONTROL_POINT_LINE       6
  51
  52 IMPLEMENT_DYNAMIC_CLASS(wxShapeTextLine, wxObject)
  53 IMPLEMENT_DYNAMIC_CLASS(wxAttachmentPoint, wxObject)
  54
  55 wxShapeTextLine::wxShapeTextLine(double the_x, double the_y, const wxString& the_line)
  56 {
  57   m_x = the_x; m_y = the_y; m_line = the_line;
  58 }
  59
  60 wxShapeTextLine::~wxShapeTextLine()
  61 {
  62 }
  63
  64 IMPLEMENT_ABSTRACT_CLASS(wxShapeEvtHandler, wxObject)
  65
  66 wxShapeEvtHandler::wxShapeEvtHandler(wxShapeEvtHandler *prev, wxShape *shape)
  67 {
  68   m_previousHandler = prev;
  69   m_handlerShape = shape;
  70 }
  71
  72 wxShapeEvtHandler::~wxShapeEvtHandler()
  73 {
  74 }
  75
  76 // Creates a copy of this event handler.
  77 wxShapeEvtHandler* wxShapeEvtHandler::CreateNewCopy()
  78 {
  79   wxShapeEvtHandler* newObject = (wxShapeEvtHandler*) GetClassInfo()->CreateObject();
  80
  81   wxASSERT( (newObject != NULL) );
  82   wxASSERT( (newObject->IsKindOf(CLASSINFO(wxShapeEvtHandler))) );
  83
  84   newObject->m_previousHandler = newObject;
  85
  86   CopyData(*newObject);
  87
  88   return newObject;
  89 }
  90
  91
  92 void wxShapeEvtHandler::OnDelete()
  93 {
  94   if (this != GetShape())
  95     delete this;
  96 }
  97
  98 void wxShapeEvtHandler::OnDraw(wxDC& dc)
  99 {
 100   if (m_previousHandler)
 101     m_previousHandler->OnDraw(dc);
 102 }
 103
 104 void wxShapeEvtHandler::OnMoveLinks(wxDC& dc)
 105 {
 106   if (m_previousHandler)
 107     m_previousHandler->OnMoveLinks(dc);
 108 }
 109
 110 void wxShapeEvtHandler::OnMoveLink(wxDC& dc, bool moveControlPoints)
 111 {
 112   if (m_previousHandler)
 113     m_previousHandler->OnMoveLink(dc, moveControlPoints);
 114 }
 115
 116 void wxShapeEvtHandler::OnDrawContents(wxDC& dc)
 117 {
 118   if (m_previousHandler)
 119     m_previousHandler->OnDrawContents(dc);
 120 }
 121
 122 void wxShapeEvtHandler::OnDrawBranches(wxDC& dc, bool erase)
 123 {
 124   if (m_previousHandler)
 125     m_previousHandler->OnDrawBranches(dc, erase);
 126 }
 127
 128 void wxShapeEvtHandler::OnSize(double x, double y)
 129 {
 130   if (m_previousHandler)
 131     m_previousHandler->OnSize(x, y);
 132 }
 133
 134 bool wxShapeEvtHandler::OnMovePre(wxDC& dc, double x, double y, double old_x, double old_y, bool display)
 135 {
 136   if (m_previousHandler)
 137     return m_previousHandler->OnMovePre(dc, x, y, old_x, old_y, display);
 138   else
 139     return true;
 140 }
 141
 142 void wxShapeEvtHandler::OnMovePost(wxDC& dc, double x, double y, double old_x, double old_y, bool display)
 143 {
 144   if (m_previousHandler)
 145     m_previousHandler->OnMovePost(dc, x, y, old_x, old_y, display);
 146 }
 147
 148 void wxShapeEvtHandler::OnErase(wxDC& dc)
 149 {
 150   if (m_previousHandler)
 151     m_previousHandler->OnErase(dc);
 152 }
 153
 154 void wxShapeEvtHandler::OnEraseContents(wxDC& dc)
 155 {
 156   if (m_previousHandler)
 157     m_previousHandler->OnEraseContents(dc);
 158 }
 159
 160 void wxShapeEvtHandler::OnHighlight(wxDC& dc)
 161 {
 162   if (m_previousHandler)
 163     m_previousHandler->OnHighlight(dc);
 164 }
 165
 166 void wxShapeEvtHandler::OnLeftClick(double x, double y, int keys, int attachment)
 167 {
 168   if (m_previousHandler)
 169     m_previousHandler->OnLeftClick(x, y, keys, attachment);
 170 }
 171
 172 void wxShapeEvtHandler::OnLeftDoubleClick(double x, double y, int keys, int attachment)
 173 {
 174   if (m_previousHandler)
 175     m_previousHandler->OnLeftDoubleClick(x, y, keys, attachment);
 176 }
 177
 178 void wxShapeEvtHandler::OnRightClick(double x, double y, int keys, int attachment)
 179 {
 180   if (m_previousHandler)
 181     m_previousHandler->OnRightClick(x, y, keys, attachment);
 182 }
 183
 184 void wxShapeEvtHandler::OnDragLeft(bool draw, double x, double y, int keys, int attachment)
 185 {
 186   if (m_previousHandler)
 187     m_previousHandler->OnDragLeft(draw, x, y, keys, attachment);
 188 }
 189
 190 void wxShapeEvtHandler::OnBeginDragLeft(double x, double y, int keys, int attachment)
 191 {
 192   if (m_previousHandler)
 193     m_previousHandler->OnBeginDragLeft(x, y, keys, attachment);
 194 }
 195
 196 void wxShapeEvtHandler::OnEndDragLeft(double x, double y, int keys, int attachment)
 197 {
 198   if (m_previousHandler)
 199     m_previousHandler->OnEndDragLeft(x, y, keys, attachment);
 200 }
 201
 202 void wxShapeEvtHandler::OnDragRight(bool draw, double x, double y, int keys, int attachment)
 203 {
 204   if (m_previousHandler)
 205     m_previousHandler->OnDragRight(draw, x, y, keys, attachment);
 206 }
 207
 208 void wxShapeEvtHandler::OnBeginDragRight(double x, double y, int keys, int attachment)
 209 {
 210   if (m_previousHandler)
 211     m_previousHandler->OnBeginDragRight(x, y, keys, attachment);
 212 }
 213
 214 void wxShapeEvtHandler::OnEndDragRight(double x, double y, int keys, int attachment)
 215 {
 216   if (m_previousHandler)
 217     m_previousHandler->OnEndDragRight(x, y, keys, attachment);
 218 }
 219
 220 // Control points ('handles') redirect control to the actual shape, to make it easier
 221 // to override sizing behaviour.
 222 void wxShapeEvtHandler::OnSizingDragLeft(wxControlPoint* pt, bool draw, double x, double y, int keys, int attachment)
 223 {
 224   if (m_previousHandler)
 225     m_previousHandler->OnSizingDragLeft(pt, draw, x, y, keys, attachment);
 226 }
 227
 228 void wxShapeEvtHandler::OnSizingBeginDragLeft(wxControlPoint* pt, double x, double y, int keys, int attachment)
 229 {
 230   if (m_previousHandler)
 231     m_previousHandler->OnSizingBeginDragLeft(pt, x, y, keys, attachment);
 232 }
 233
 234 void wxShapeEvtHandler::OnSizingEndDragLeft(wxControlPoint* pt, double x, double y, int keys, int attachment)
 235 {
 236   if (m_previousHandler)
 237     m_previousHandler->OnSizingEndDragLeft(pt, x, y, keys, attachment);
 238 }
 239
 240 void wxShapeEvtHandler::OnDrawOutline(wxDC& dc, double x, double y, double w, double h)
 241 {
 242   if (m_previousHandler)
 243     m_previousHandler->OnDrawOutline(dc, x, y, w, h);
 244 }
 245
 246 void wxShapeEvtHandler::OnDrawControlPoints(wxDC& dc)
 247 {
 248   if (m_previousHandler)
 249     m_previousHandler->OnDrawControlPoints(dc);
 250 }
 251
 252 void wxShapeEvtHandler::OnEraseControlPoints(wxDC& dc)
 253 {
 254   if (m_previousHandler)
 255     m_previousHandler->OnEraseControlPoints(dc);
 256 }
 257
 258 // Can override this to prevent or intercept line reordering.
 259 void wxShapeEvtHandler::OnChangeAttachment(int attachment, wxLineShape* line, wxList& ordering)
 260 {
 261   if (m_previousHandler)
 262     m_previousHandler->OnChangeAttachment(attachment, line, ordering);
 263 }
 264
 265 IMPLEMENT_ABSTRACT_CLASS(wxShape, wxShapeEvtHandler)
 266
 267 wxShape::wxShape(wxShapeCanvas *can)
 268 {
 269   m_eventHandler = this;
 270   SetShape(this);
 271   m_id = 0;
 272   m_formatted = false;
 273   m_canvas = can;
 274   m_xpos = 0.0; m_ypos = 0.0;
 275   m_pen = g_oglBlackPen;
 276   m_brush = wxWHITE_BRUSH;
 277   m_font = g_oglNormalFont;
 278   m_textColour = wxT("BLACK");
 279   m_textColourName = wxT("BLACK");
 280   m_visible = false;
 281   m_selected = false;
 282   m_attachmentMode = ATTACHMENT_MODE_NONE;
 283   m_spaceAttachments = true;
 284   m_disableLabel = false;
 285   m_fixedWidth = false;
 286   m_fixedHeight = false;
 287   m_drawHandles = true;
 288   m_sensitivity = OP_ALL;
 289   m_draggable = true;
 290   m_parent = NULL;
 291   m_formatMode = FORMAT_CENTRE_HORIZ | FORMAT_CENTRE_VERT;
 292   m_shadowMode = SHADOW_NONE;
 293   m_shadowOffsetX = 6;
 294   m_shadowOffsetY = 6;
 295   m_shadowBrush = wxBLACK_BRUSH;
 296   m_textMarginX = 5;
 297   m_textMarginY = 5;
 298   m_regionName = wxT("0");
 299   m_centreResize = true;
 300   m_maintainAspectRatio = false;
 301   m_highlighted = false;
 302   m_rotation = 0.0;
 303   m_branchNeckLength = 10;
 304   m_branchStemLength = 10;
 305   m_branchSpacing = 10;
 306   m_branchStyle = BRANCHING_ATTACHMENT_NORMAL;
 307
 308   // Set up a default region. Much of the above will be put into
 309   // the region eventually (the duplication is for compatibility)
 310   wxShapeRegion *region = new wxShapeRegion;
 311   m_regions.Append(region);
 312   region->SetName(wxT("0"));
 313   region->SetFont(g_oglNormalFont);
 314   region->SetFormatMode(FORMAT_CENTRE_HORIZ | FORMAT_CENTRE_VERT);
 315   region->SetColour(wxT("BLACK"));
 316 }
 317
 318 wxShape::~wxShape()
 319 {
 320   if (m_parent)
 321     m_parent->GetChildren().DeleteObject(this);
 322
 323   ClearText();
 324   ClearRegions();
 325   ClearAttachments();
 326
 327   if (m_canvas)
 328     m_canvas->RemoveShape(this);
 329
 330   GetEventHandler()->OnDelete();
 331 }
 332
 333 void wxShape::SetHighlight(bool hi, bool recurse)
 334 {
 335   m_highlighted = hi;
 336   if (recurse)
 337   {
 338     wxNode *node = m_children.GetFirst();
 339     while (node)
 340     {
 341       wxShape *child = (wxShape *)node->GetData();
 342       child->SetHighlight(hi, recurse);
 343       node = node->GetNext();
 344     }
 345   }
 346 }
 347
 348 void wxShape::SetSensitivityFilter(int sens, bool recursive)
 349 {
 350   if (sens & OP_DRAG_LEFT)
 351     m_draggable = true;
 352   else
 353     m_draggable = false;
 354
 355   m_sensitivity = sens;
 356   if (recursive)
 357   {
 358     wxNode *node = m_children.GetFirst();
 359     while (node)
 360     {
 361       wxShape *obj = (wxShape *)node->GetData();
 362       obj->SetSensitivityFilter(sens, true);
 363       node = node->GetNext();
 364     }
 365   }
 366 }
 367
 368 void wxShape::SetDraggable(bool drag, bool recursive)
 369 {
 370   m_draggable = drag;
 371   if (m_draggable)
 372     m_sensitivity |= OP_DRAG_LEFT;
 373   else
 374     if (m_sensitivity & OP_DRAG_LEFT)
 375       m_sensitivity = m_sensitivity - OP_DRAG_LEFT;
 376
 377   if (recursive)
 378   {
 379     wxNode *node = m_children.GetFirst();
 380     while (node)
 381     {
 382       wxShape *obj = (wxShape *)node->GetData();
 383       obj->SetDraggable(drag, true);
 384       node = node->GetNext();
 385     }
 386   }
 387 }
 388
 389 void wxShape::SetDrawHandles(bool drawH)
 390 {
 391   m_drawHandles = drawH;
 392   wxNode *node = m_children.GetFirst();
 393   while (node)
 394   {
 395     wxShape *obj = (wxShape *)node->GetData();
 396     obj->SetDrawHandles(drawH);
 397     node = node->GetNext();
 398   }
 399 }
 400
 401 void wxShape::SetShadowMode(int mode, bool redraw)
 402 {
 403   if (redraw && GetCanvas())
 404   {
 405     wxClientDC dc(GetCanvas());
 406     GetCanvas()->PrepareDC(dc);
 407     Erase(dc);
 408
 409     m_shadowMode = mode;
 410
 411     Draw(dc);
 412   }
 413   else
 414   {
 415     m_shadowMode = mode;
 416   }
 417 }
 418
 419 void wxShape::SetCanvas(wxShapeCanvas *theCanvas)
 420 {
 421   m_canvas = theCanvas;
 422   wxNode *node = m_children.GetFirst();
 423   while (node)
 424   {
 425     wxShape *child = (wxShape *)node->GetData();
 426     child->SetCanvas(theCanvas);
 427     node = node->GetNext();
 428   }
 429 }
 430
 431 void wxShape::AddToCanvas(wxShapeCanvas *theCanvas, wxShape *addAfter)
 432 {
 433   theCanvas->AddShape(this, addAfter);
 434   wxNode *node = m_children.GetFirst();
 435   wxShape *lastImage = this;
 436   while (node)
 437   {
 438     wxShape *object = (wxShape *)node->GetData();
 439     object->AddToCanvas(theCanvas, lastImage);
 440     lastImage = object;
 441
 442     node = node->GetNext();
 443   }
 444 }
 445
 446 // Insert at front of canvas
 447 void wxShape::InsertInCanvas(wxShapeCanvas *theCanvas)
 448 {
 449   theCanvas->InsertShape(this);
 450   wxNode *node = m_children.GetFirst();
 451   wxShape *lastImage = this;
 452   while (node)
 453   {
 454     wxShape *object = (wxShape *)node->GetData();
 455     object->AddToCanvas(theCanvas, lastImage);
 456     lastImage = object;
 457
 458     node = node->GetNext();
 459   }
 460 }
 461
 462 void wxShape::RemoveFromCanvas(wxShapeCanvas *theCanvas)
 463 {
 464   if (Selected())
 465     Select(false);
 466   theCanvas->RemoveShape(this);
 467   wxNode *node = m_children.GetFirst();
 468   while (node)
 469   {
 470     wxShape *object = (wxShape *)node->GetData();
 471     object->RemoveFromCanvas(theCanvas);
 472
 473     node = node->GetNext();
 474   }
 475 }
 476
 477 void wxShape::ClearAttachments()
 478 {
 479   wxNode *node = m_attachmentPoints.GetFirst();
 480   while (node)
 481   {
 482     wxAttachmentPoint *point = (wxAttachmentPoint *)node->GetData();
 483     delete point;
 484     node = node->GetNext();
 485   }
 486   m_attachmentPoints.Clear();
 487 }
 488
 489 void wxShape::ClearText(int regionId)
 490 {
 491   if (regionId == 0)
 492   {
 493     m_text.DeleteContents(true);
 494     m_text.Clear();
 495     m_text.DeleteContents(false);
 496   }
 497   wxNode *node = m_regions.Item(regionId);
 498   if (!node)
 499     return;
 500   wxShapeRegion *region = (wxShapeRegion *)node->GetData();
 501   region->ClearText();
 502 }
 503
 504 void wxShape::ClearRegions()
 505 {
 506   wxNode *node = m_regions.GetFirst();
 507   while (node)
 508   {
 509     wxShapeRegion *region = (wxShapeRegion *)node->GetData();
 510     wxNode *next = node->GetNext();
 511     delete region;
 512     delete node;
 513     node = next;
 514   }
 515 }
 516
 517 void wxShape::AddRegion(wxShapeRegion *region)
 518 {
 519   m_regions.Append(region);
 520 }
 521
 522 void wxShape::SetDefaultRegionSize()
 523 {
 524   wxNode *node = m_regions.GetFirst();
 525   if (!node) return;
 526   wxShapeRegion *region = (wxShapeRegion *)node->GetData();
 527   double w, h;
 528   GetBoundingBoxMin(&w, &h);
 529   region->SetSize(w, h);
 530 }
 531
 532 bool wxShape::HitTest(double x, double y, int *attachment, double *distance)
 533 {
 534 //  if (!sensitive)
 535 //    return false;
 536
 537   double width = 0.0, height = 0.0;
 538   GetBoundingBoxMin(&width, &height);
 539   if (fabs(width) < 4.0) width = 4.0;
 540   if (fabs(height) < 4.0) height = 4.0;
 541
 542   width += (double)4.0; height += (double)4.0; // Allowance for inaccurate mousing
 543
 544   double left = (double)(m_xpos - (width/2.0));
 545   double top = (double)(m_ypos - (height/2.0));
 546   double right = (double)(m_xpos + (width/2.0));
 547   double bottom = (double)(m_ypos + (height/2.0));
 548
 549   int nearest_attachment = 0;
 550
 551   // If within the bounding box, check the attachment points
 552   // within the object.
 553
 554   if (x >= left && x <= right && y >= top && y <= bottom)
 555   {
 556     int n = GetNumberOfAttachments();
 557     double nearest = 999999.0;
 558
 559     // GetAttachmentPosition[Edge] takes a logical attachment position,
 560     // i.e. if it's rotated through 90%, position 0 is East-facing.
 561
 562     for (int i = 0; i < n; i++)
 563     {
 564       double xp, yp;
 565       if (GetAttachmentPositionEdge(i, &xp, &yp))
 566       {
 567         double l = (double)sqrt(((xp - x) * (xp - x)) +
 568                    ((yp - y) * (yp - y)));
 569
 570         if (l < nearest)
 571         {
 572           nearest = l;
 573           nearest_attachment = i;
 574         }
 575       }
 576     }
 577     *attachment = nearest_attachment;
 578     *distance = nearest;
 579     return true;
 580   }
 581   else return false;
 582 }
 583
 584 // Format a text string according to the region size, adding
 585 // strings with positions to region text list
 586
 587 static bool GraphicsInSizeToContents = false; // Infinite recursion elimination
 588 void wxShape::FormatText(wxDC& dc, const wxString& s, int i)
 589 {
 590   double w, h;
 591   ClearText(i);
 592
 593   if (m_regions.GetCount() < 1)
 594     return;
 595   wxNode *node = m_regions.Item(i);
 596   if (!node)
 597     return;
 598
 599   wxShapeRegion *region = (wxShapeRegion *)node->GetData();
 600   // region->SetText(s);  // don't set the formatted text yet, it will be done below
 601   region->m_regionText = s;
 602   dc.SetFont(* region->GetFont());
 603
 604   region->GetSize(&w, &h);
 605
 606   wxStringList *stringList = oglFormatText(dc, s, (w-2*m_textMarginX), (h-2*m_textMarginY), region->GetFormatMode());
 607   node = (wxNode*)stringList->GetFirst();
 608   while (node)
 609   {
 610     wxChar *s = (wxChar *)node->GetData();
 611     wxShapeTextLine *line = new wxShapeTextLine(0.0, 0.0, s);
 612     region->GetFormattedText().Append((wxObject *)line);
 613     node = node->GetNext();
 614   }
 615   delete stringList;
 616   double actualW = w;
 617   double actualH = h;
 618   // Don't try to resize an object with more than one image (this case should be dealt
 619   // with by overriden handlers)
 620   if ((region->GetFormatMode() & FORMAT_SIZE_TO_CONTENTS) &&
 621       (region->GetFormattedText().GetCount() > 0) &&
 622       (m_regions.GetCount() == 1) && !GraphicsInSizeToContents)
 623   {
 624     oglGetCentredTextExtent(dc, &(region->GetFormattedText()), m_xpos, m_ypos, w, h, &actualW, &actualH);
 625     if ((actualW+2*m_textMarginX != w ) || (actualH+2*m_textMarginY != h))
 626     {
 627       // If we are a descendant of a composite, must make sure the composite gets
 628       // resized properly
 629       wxShape *topAncestor = GetTopAncestor();
 630
 631       if (topAncestor != this)
 632       {
 633         // Make sure we don't recurse infinitely
 634         GraphicsInSizeToContents = true;
 635
 636         wxCompositeShape *composite = (wxCompositeShape *)topAncestor;
 637         composite->Erase(dc);
 638         SetSize(actualW+2*m_textMarginX, actualH+2*m_textMarginY);
 639         Move(dc, m_xpos, m_ypos);
 640         composite->CalculateSize();
 641         if (composite->Selected())
 642         {
 643           composite->DeleteControlPoints(& dc);
 644           composite->MakeControlPoints();
 645           composite->MakeMandatoryControlPoints();
 646         }
 647         // Where infinite recursion might happen if we didn't stop it
 648         composite->Draw(dc);
 649
 650         GraphicsInSizeToContents = false;
 651       }
 652       else
 653       {
 654         Erase(dc);
 655         SetSize(actualW+2*m_textMarginX, actualH+2*m_textMarginY);
 656         Move(dc, m_xpos, m_ypos);
 657       }
 658       SetSize(actualW+2*m_textMarginX, actualH+2*m_textMarginY);
 659       Move(dc, m_xpos, m_ypos);
 660       EraseContents(dc);
 661     }
 662   }
 663   oglCentreText(dc, &(region->GetFormattedText()), m_xpos, m_ypos, actualW-2*m_textMarginX, actualH-2*m_textMarginY, region->GetFormatMode());
 664   m_formatted = true;
 665 }
 666
 667 void wxShape::Recentre(wxDC& dc)
 668 {
 669   double w, h;
 670   GetBoundingBoxMin(&w, &h);
 671
 672   int noRegions = m_regions.GetCount();
 673   for (int i = 0; i < noRegions; i++)
 674   {
 675     wxNode *node = m_regions.Item(i);
 676     if (node)
 677     {
 678       wxShapeRegion *region = (wxShapeRegion *)node->GetData();
 679       oglCentreText(dc, &(region->GetFormattedText()), m_xpos, m_ypos, w-2*m_textMarginX, h-2*m_textMarginY, region->GetFormatMode());
 680     }
 681   }
 682 }
 683
 684 bool wxShape::GetPerimeterPoint(double WXUNUSED(x1), double WXUNUSED(y1),
 685                                      double WXUNUSED(x2), double WXUNUSED(y2),
 686                                      double *WXUNUSED(x3), double *WXUNUSED(y3))
 687 {
 688   return false;
 689 }
 690
 691 void wxShape::SetPen(wxPen *the_pen)
 692 {
 693   m_pen = the_pen;
 694 }
 695
 696 void wxShape::SetBrush(wxBrush *the_brush)
 697 {
 698   m_brush = the_brush;
 699 }
 700
 701 // Get the top-most (non-division) ancestor, or self
 702 wxShape *wxShape::GetTopAncestor()
 703 {
 704   if (!GetParent())
 705     return this;
 706
 707   if (GetParent()->IsKindOf(CLASSINFO(wxDivisionShape)))
 708     return this;
 709   else return GetParent()->GetTopAncestor();
 710 }
 711
 712 /*
 713  * Region functions
 714  *
 715  */
 716 void wxShape::SetFont(wxFont *the_font, int regionId)
 717 {
 718   m_font = the_font;
 719   wxNode *node = m_regions.Item(regionId);
 720   if (!node)
 721     return;
 722   wxShapeRegion *region = (wxShapeRegion *)node->GetData();
 723   region->SetFont(the_font);
 724 }
 725
 726 wxFont *wxShape::GetFont(int n) const
 727 {
 728   wxNode *node = m_regions.Item(n);
 729   if (!node)
 730     return NULL;
 731   wxShapeRegion *region = (wxShapeRegion *)node->GetData();
 732   return region->GetFont();
 733 }
 734
 735 void wxShape::SetFormatMode(int mode, int regionId)
 736 {
 737   wxNode *node = m_regions.Item(regionId);
 738   if (!node)
 739     return;
 740   wxShapeRegion *region = (wxShapeRegion *)node->GetData();
 741   region->SetFormatMode(mode);
 742 }
 743
 744 int wxShape::GetFormatMode(int regionId) const
 745 {
 746   wxNode *node = m_regions.Item(regionId);
 747   if (!node)
 748     return 0;
 749   wxShapeRegion *region = (wxShapeRegion *)node->GetData();
 750   return region->GetFormatMode();
 751 }
 752
 753 void wxShape::SetTextColour(const wxString& the_colour, int regionId)
 754 {
 755   m_textColour = wxTheColourDatabase->Find(the_colour);
 756   m_textColourName = the_colour;
 757
 758   wxNode *node = m_regions.Item(regionId);
 759   if (!node)
 760     return;
 761   wxShapeRegion *region = (wxShapeRegion *)node->GetData();
 762   region->SetColour(the_colour);
 763 }
 764
 765 wxString wxShape::GetTextColour(int regionId) const
 766 {
 767   wxNode *node = m_regions.Item(regionId);
 768   if (!node)
 769     return wxEmptyString;
 770   wxShapeRegion *region = (wxShapeRegion *)node->GetData();
 771   return region->GetColour();
 772 }
 773
 774 void wxShape::SetRegionName(const wxString& name, int regionId)
 775 {
 776   wxNode *node = m_regions.Item(regionId);
 777   if (!node)
 778     return;
 779   wxShapeRegion *region = (wxShapeRegion *)node->GetData();
 780   region->SetName(name);
 781 }
 782
 783 wxString wxShape::GetRegionName(int regionId)
 784 {
 785   wxNode *node = m_regions.Item(regionId);
 786   if (!node)
 787     return wxEmptyString;
 788   wxShapeRegion *region = (wxShapeRegion *)node->GetData();
 789   return region->GetName();
 790 }
 791
 792 int wxShape::GetRegionId(const wxString& name)
 793 {
 794   wxNode *node = m_regions.GetFirst();
 795   int i = 0;
 796   while (node)
 797   {
 798     wxShapeRegion *region = (wxShapeRegion *)node->GetData();
 799     if (region->GetName() == name)
 800       return i;
 801     node = node->GetNext();
 802     i ++;
 803   }
 804   return -1;
 805 }
 806
 807 // Name all m_regions in all subimages recursively.
 808 void wxShape::NameRegions(const wxString& parentName)
 809 {
 810   int n = GetNumberOfTextRegions();
 811   wxString buff;
 812   for (int i = 0; i < n; i++)
 813   {
 814     if (parentName.Length() > 0)
 815       buff << parentName << wxT(".") << i;
 816     else
 817       buff << i;
 818     SetRegionName(buff, i);
 819   }
 820   wxNode *node = m_children.GetFirst();
 821   int j = 0;
 822   while (node)
 823   {
 824     buff.Empty();
 825     wxShape *child = (wxShape *)node->GetData();
 826     if (parentName.Length() > 0)
 827       buff << parentName << wxT(".") << j;
 828     else
 829       buff << j;
 830     child->NameRegions(buff);
 831     node = node->GetNext();
 832     j ++;
 833   }
 834 }
 835
 836 // Get a region by name, possibly looking recursively into composites.
 837 wxShape *wxShape::FindRegion(const wxString& name, int *regionId)
 838 {
 839   int id = GetRegionId(name);
 840   if (id > -1)
 841   {
 842     *regionId = id;
 843     return this;
 844   }
 845
 846   wxNode *node = m_children.GetFirst();
 847   while (node)
 848   {
 849     wxShape *child = (wxShape *)node->GetData();
 850     wxShape *actualImage = child->FindRegion(name, regionId);
 851     if (actualImage)
 852       return actualImage;
 853     node = node->GetNext();
 854   }
 855   return NULL;
 856 }
 857
 858 // Finds all region names for this image (composite or simple).
 859 // Supply empty string list.
 860 void wxShape::FindRegionNames(wxStringList& list)
 861 {
 862   int n = GetNumberOfTextRegions();
 863   for (int i = 0; i < n; i++)
 864   {
 865     wxString name(GetRegionName(i));
 866     list.Add(name);
 867   }
 868
 869   wxNode *node = m_children.GetFirst();
 870   while (node)
 871   {
 872     wxShape *child = (wxShape *)node->GetData();
 873     child->FindRegionNames(list);
 874     node = node->GetNext();
 875   }
 876 }
 877
 878 void wxShape::AssignNewIds()
 879 {
 880 //  if (m_id == 0)
 881   m_id = wxNewId();
 882   wxNode *node = m_children.GetFirst();
 883   while (node)
 884   {
 885     wxShape *child = (wxShape *)node->GetData();
 886     child->AssignNewIds();
 887     node = node->GetNext();
 888   }
 889 }
 890
 891 void wxShape::OnDraw(wxDC& WXUNUSED(dc))
 892 {
 893 }
 894
 895 void wxShape::OnMoveLinks(wxDC& dc)
 896 {
 897   // Want to set the ends of all attached links
 898   // to point to/from this object
 899
 900   wxNode *current = m_lines.GetFirst();
 901   while (current)
 902   {
 903     wxLineShape *line = (wxLineShape *)current->GetData();
 904     line->GetEventHandler()->OnMoveLink(dc);
 905     current = current->GetNext();
 906   }
 907 }
 908
 909
 910 void wxShape::OnDrawContents(wxDC& dc)
 911 {
 912   double bound_x, bound_y;
 913   GetBoundingBoxMin(&bound_x, &bound_y);
 914     if (m_regions.GetCount() < 1) return;
 915
 916     if (m_pen) dc.SetPen(* m_pen);
 917
 918     wxShapeRegion *region = (wxShapeRegion *)m_regions.GetFirst()->GetData();
 919     if (region->GetFont()) dc.SetFont(* region->GetFont());
 920
 921     dc.SetTextForeground(region->GetActualColourObject());
 922     dc.SetBackgroundMode(wxTRANSPARENT);
 923     if (!m_formatted)
 924     {
 925       oglCentreText(dc, &(region->GetFormattedText()), m_xpos, m_ypos, bound_x-2*m_textMarginX, bound_y-2*m_textMarginY, region->GetFormatMode());
 926       m_formatted = true;
 927     }
 928     if (!GetDisableLabel())
 929     {
 930       oglDrawFormattedText(dc, &(region->GetFormattedText()), m_xpos, m_ypos, bound_x-2*m_textMarginX, bound_y-2*m_textMarginY, region->GetFormatMode());
 931     }
 932 }
 933
 934 void wxShape::DrawContents(wxDC& dc)
 935 {
 936   GetEventHandler()->OnDrawContents(dc);
 937 }
 938
 939 void wxShape::OnSize(double WXUNUSED(x), double WXUNUSED(y))
 940 {
 941 }
 942
 943 bool wxShape::OnMovePre(wxDC& WXUNUSED(dc), double WXUNUSED(x), double WXUNUSED(y), double WXUNUSED(old_x), double WXUNUSED(old_y), bool WXUNUSED(display))
 944 {
 945   return true;
 946 }
 947
 948 void wxShape::OnMovePost(wxDC& WXUNUSED(dc), double WXUNUSED(x), double WXUNUSED(y), double WXUNUSED(old_x), double WXUNUSED(old_y), bool WXUNUSED(display))
 949 {
 950 }
 951
 952 void wxShape::OnErase(wxDC& dc)
 953 {
 954   if (!m_visible)
 955     return;
 956
 957   // Erase links
 958   wxNode *current = m_lines.GetFirst();
 959   while (current)
 960   {
 961     wxLineShape *line = (wxLineShape *)current->GetData();
 962     line->GetEventHandler()->OnErase(dc);
 963     current = current->GetNext();
 964   }
 965   GetEventHandler()->OnEraseContents(dc);
 966 }
 967
 968 void wxShape::OnEraseContents(wxDC& dc)
 969 {
 970   if (!m_visible)
 971     return;
 972
 973   double maxX, maxY, minX, minY;
 974   double xp = GetX();
 975   double yp = GetY();
 976   GetBoundingBoxMin(&minX, &minY);
 977   GetBoundingBoxMax(&maxX, &maxY);
 978   double topLeftX = (double)(xp - (maxX / 2.0) - 2.0);
 979   double topLeftY = (double)(yp - (maxY / 2.0) - 2.0);
 980
 981     int penWidth = 0;
 982     if (m_pen)
 983       penWidth = m_pen->GetWidth();
 984
 985     dc.SetPen(GetBackgroundPen());
 986     dc.SetBrush(GetBackgroundBrush());
 987
 988     dc.DrawRectangle(WXROUND(topLeftX - penWidth), WXROUND(topLeftY - penWidth),
 989                       WXROUND(maxX + penWidth*2.0 + 4.0), WXROUND(maxY + penWidth*2.0 + 4.0));
 990 }
 991
 992 void wxShape::EraseLinks(wxDC& dc, int attachment, bool recurse)
 993 {
 994   if (!m_visible)
 995     return;
 996
 997   wxNode *current = m_lines.GetFirst();
 998   while (current)
 999   {
1000     wxLineShape *line = (wxLineShape *)current->GetData();
1001     if (attachment == -1 || ((line->GetTo() == this && line->GetAttachmentTo() == attachment) ||
1002                              (line->GetFrom() == this && line->GetAttachmentFrom() == attachment)))
1003       line->GetEventHandler()->OnErase(dc);
1004     current = current->GetNext();
1005   }
1006   if (recurse)
1007   {
1008     wxNode *node = m_children.GetFirst();
1009     while (node)
1010     {
1011       wxShape *child = (wxShape *)node->GetData();
1012       child->EraseLinks(dc, attachment, recurse);
1013       node = node->GetNext();
1014     }
1015   }
1016 }
1017
1018 void wxShape::DrawLinks(wxDC& dc, int attachment, bool recurse)
1019 {
1020   if (!m_visible)
1021     return;
1022
1023   wxNode *current = m_lines.GetFirst();
1024   while (current)
1025   {
1026     wxLineShape *line = (wxLineShape *)current->GetData();
1027     if (attachment == -1 ||
1028         (line->GetTo() == this && line->GetAttachmentTo() == attachment) ||
1029         (line->GetFrom() == this && line->GetAttachmentFrom() == attachment))
1030       line->Draw(dc);
1031     current = current->GetNext();
1032   }
1033   if (recurse)
1034   {
1035     wxNode *node = m_children.GetFirst();
1036     while (node)
1037     {
1038       wxShape *child = (wxShape *)node->GetData();
1039       child->DrawLinks(dc, attachment, recurse);
1040       node = node->GetNext();
1041     }
1042   }
1043 }
1044
1045 // Returns true if pt1 <= pt2 in the sense that one point comes before another on an
1046 // edge of the shape.
1047 // attachmentPoint is the attachment point (= side) in question.
1048
1049 // This is the default, rectangular implementation.
1050 bool wxShape::AttachmentSortTest(int attachmentPoint, const wxRealPoint& pt1, const wxRealPoint& pt2)
1051 {
1052     int physicalAttachment = LogicalToPhysicalAttachment(attachmentPoint);
1053     switch (physicalAttachment)
1054     {
1055         case 0:
1056         case 2:
1057         {
1058           return (pt1.x <= pt2.x) ;
1059         }
1060         case 1:
1061         case 3:
1062         {
1063           return (pt1.y <= pt2.y) ;
1064         }
1065     }
1066
1067     return false;
1068 }
1069
1070 bool wxShape::MoveLineToNewAttachment(wxDC& dc, wxLineShape *to_move,
1071                                        double x, double y)
1072 {
1073   if (GetAttachmentMode() == ATTACHMENT_MODE_NONE)
1074       return false;
1075
1076   int newAttachment, oldAttachment;
1077   double distance;
1078
1079   // Is (x, y) on this object? If so, find the new attachment point
1080   // the user has moved the point to
1081   bool hit = HitTest(x, y, &newAttachment, &distance);
1082   if (!hit)
1083     return false;
1084
1085   EraseLinks(dc);
1086
1087   if (to_move->GetTo() == this)
1088     oldAttachment = to_move->GetAttachmentTo();
1089   else
1090     oldAttachment = to_move->GetAttachmentFrom();
1091
1092   // The links in a new ordering.
1093   wxList newOrdering;
1094
1095   // First, add all links to the new list.
1096   wxNode *node = m_lines.GetFirst();
1097   while (node)
1098   {
1099     newOrdering.Append(node->GetData());
1100     node = node->GetNext();
1101   }
1102
1103   // Delete the line object from the list of links; we're going to move
1104   // it to another position in the list
1105   newOrdering.DeleteObject(to_move);
1106
1107   double old_x = (double) -99999.9;
1108   double old_y = (double) -99999.9;
1109
1110   node = newOrdering.GetFirst();
1111   bool found = false;
1112
1113   while (!found && node)
1114   {
1115     wxLineShape *line = (wxLineShape *)node->GetData();
1116     if ((line->GetTo() == this && oldAttachment == line->GetAttachmentTo()) ||
1117         (line->GetFrom() == this && oldAttachment == line->GetAttachmentFrom()))
1118     {
1119       double startX, startY, endX, endY;
1120       double xp, yp;
1121       line->GetEnds(&startX, &startY, &endX, &endY);
1122       if (line->GetTo() == this)
1123       {
1124         xp = endX;
1125         yp = endY;
1126       } else
1127       {
1128         xp = startX;
1129         yp = startY;
1130       }
1131
1132       wxRealPoint thisPoint(xp, yp);
1133       wxRealPoint lastPoint(old_x, old_y);
1134       wxRealPoint newPoint(x, y);
1135
1136       if (AttachmentSortTest(newAttachment, newPoint, thisPoint) && AttachmentSortTest(newAttachment, lastPoint, newPoint))
1137       {
1138         found = true;
1139         newOrdering.Insert(node, to_move);
1140       }
1141
1142       old_x = xp;
1143       old_y = yp;
1144     }
1145     node = node->GetNext();
1146   }
1147
1148   if (!found)
1149     newOrdering.Append(to_move);
1150
1151   GetEventHandler()->OnChangeAttachment(newAttachment, to_move, newOrdering);
1152
1153   return true;
1154 }
1155
1156 void wxShape::OnChangeAttachment(int attachment, wxLineShape* line, wxList& ordering)
1157 {
1158     if (line->GetTo() == this)
1159         line->SetAttachmentTo(attachment);
1160     else
1161         line->SetAttachmentFrom(attachment);
1162
1163     ApplyAttachmentOrdering(ordering);
1164
1165     wxClientDC dc(GetCanvas());
1166     GetCanvas()->PrepareDC(dc);
1167
1168     MoveLinks(dc);
1169
1170     if (!GetCanvas()->GetQuickEditMode()) GetCanvas()->Redraw(dc);
1171 }
1172
1173 // Reorders the lines according to the given list.
1174 void wxShape::ApplyAttachmentOrdering(wxList& linesToSort)
1175 {
1176   // This is a temporary store of all the lines.
1177   wxList linesStore;
1178
1179   wxNode *node = m_lines.GetFirst();
1180   while (node)
1181   {
1182     wxLineShape *line = (wxLineShape *)node->GetData();
1183     linesStore.Append(line);
1184     node = node->GetNext();;
1185   }
1186
1187   m_lines.Clear();
1188
1189   node = linesToSort.GetFirst();
1190   while (node)
1191   {
1192     wxLineShape *line = (wxLineShape *)node->GetData();
1193     if (linesStore.Member(line))
1194     {
1195       // Done this one
1196       linesStore.DeleteObject(line);
1197       m_lines.Append(line);
1198     }
1199     node = node->GetNext();
1200   }
1201
1202   // Now add any lines that haven't been listed in linesToSort.
1203   node = linesStore.GetFirst();
1204   while (node)
1205   {
1206     wxLineShape *line = (wxLineShape *)node->GetData();
1207     m_lines.Append(line);
1208     node = node->GetNext();
1209   }
1210 }
1211
1212 // Reorders the lines coming into the node image at this attachment
1213 // position, in the order in which they appear in linesToSort.
1214 // Any remaining lines not in the list will be added to the end.
1215 void wxShape::SortLines(int attachment, wxList& linesToSort)
1216 {
1217   // This is a temporary store of all the lines at this attachment
1218   // point. We'll tick them off as we've processed them.
1219   wxList linesAtThisAttachment;
1220
1221   wxNode *node = m_lines.GetFirst();
1222   while (node)
1223   {
1224     wxLineShape *line = (wxLineShape *)node->GetData();
1225     wxNode *next = node->GetNext();
1226     if ((line->GetTo() == this && line->GetAttachmentTo() == attachment) ||
1227         (line->GetFrom() == this && line->GetAttachmentFrom() == attachment))
1228     {
1229       linesAtThisAttachment.Append(line);
1230       delete node;
1231       node = next;
1232     }
1233     else node = node->GetNext();
1234   }
1235
1236   node = linesToSort.GetFirst();
1237   while (node)
1238   {
1239     wxLineShape *line = (wxLineShape *)node->GetData();
1240     if (linesAtThisAttachment.Member(line))
1241     {
1242       // Done this one
1243       linesAtThisAttachment.DeleteObject(line);
1244       m_lines.Append(line);
1245     }
1246     node = node->GetNext();
1247   }
1248
1249   // Now add any lines that haven't been listed in linesToSort.
1250   node = linesAtThisAttachment.GetFirst();
1251   while (node)
1252   {
1253     wxLineShape *line = (wxLineShape *)node->GetData();
1254     m_lines.Append(line);
1255     node = node->GetNext();
1256   }
1257 }
1258
1259 void wxShape::OnHighlight(wxDC& WXUNUSED(dc))
1260 {
1261 }
1262
1263 void wxShape::OnLeftClick(double x, double y, int keys, int attachment)
1264 {
1265   if ((m_sensitivity & OP_CLICK_LEFT) != OP_CLICK_LEFT)
1266   {
1267     attachment = 0;
1268     double dist;
1269     if (m_parent)
1270     {
1271       m_parent->HitTest(x, y, &attachment, &dist);
1272       m_parent->GetEventHandler()->OnLeftClick(x, y, keys, attachment);
1273     }
1274     return;
1275   }
1276 }
1277
1278 void wxShape::OnRightClick(double x, double y, int keys, int attachment)
1279 {
1280   if ((m_sensitivity & OP_CLICK_RIGHT) != OP_CLICK_RIGHT)
1281   {
1282     attachment = 0;
1283     double dist;
1284     if (m_parent)
1285     {
1286       m_parent->HitTest(x, y, &attachment, &dist);
1287       m_parent->GetEventHandler()->OnRightClick(x, y, keys, attachment);
1288     }
1289     return;
1290   }
1291 }
1292
1293 double DragOffsetX = 0.0;
1294 double DragOffsetY = 0.0;
1295
1296 void wxShape::OnDragLeft(bool draw, double x, double y, int keys, int attachment)
1297 {
1298   if ((m_sensitivity & OP_DRAG_LEFT) != OP_DRAG_LEFT)
1299   {
1300     attachment = 0;
1301     double dist;
1302     if (m_parent)
1303     {
1304       m_parent->HitTest(x, y, &attachment, &dist);
1305       m_parent->GetEventHandler()->OnDragLeft(draw, x, y, keys, attachment);
1306     }
1307     return;
1308   }
1309
1310   wxClientDC dc(GetCanvas());
1311   GetCanvas()->PrepareDC(dc);
1312
1313   dc.SetLogicalFunction(OGLRBLF);
1314
1315   wxPen dottedPen(wxColour(0, 0, 0), 1, wxDOT);
1316   dc.SetPen(dottedPen);
1317   dc.SetBrush(* wxTRANSPARENT_BRUSH);
1318
1319   double xx, yy;
1320   xx = x + DragOffsetX;
1321   yy = y + DragOffsetY;
1322
1323   m_canvas->Snap(&xx, &yy);
1324 //  m_xpos = xx; m_ypos = yy;
1325   double w, h;
1326   GetBoundingBoxMax(&w, &h);
1327   GetEventHandler()->OnDrawOutline(dc, xx, yy, w, h);
1328 }
1329
1330 void wxShape::OnBeginDragLeft(double x, double y, int keys, int attachment)
1331 {
1332   if ((m_sensitivity & OP_DRAG_LEFT) != OP_DRAG_LEFT)
1333   {
1334     attachment = 0;
1335     double dist;
1336     if (m_parent)
1337     {
1338       m_parent->HitTest(x, y, &attachment, &dist);
1339       m_parent->GetEventHandler()->OnBeginDragLeft(x, y, keys, attachment);
1340     }
1341     return;
1342   }
1343
1344   DragOffsetX = m_xpos - x;
1345   DragOffsetY = m_ypos - y;
1346
1347   wxClientDC dc(GetCanvas());
1348   GetCanvas()->PrepareDC(dc);
1349
1350   // New policy: don't erase shape until end of drag.
1351 //  Erase(dc);
1352
1353   double xx, yy;
1354   xx = x + DragOffsetX;
1355   yy = y + DragOffsetY;
1356   m_canvas->Snap(&xx, &yy);
1357 //  m_xpos = xx; m_ypos = yy;
1358   dc.SetLogicalFunction(OGLRBLF);
1359
1360   wxPen dottedPen(wxColour(0, 0, 0), 1, wxDOT);
1361   dc.SetPen(dottedPen);
1362   dc.SetBrush((* wxTRANSPARENT_BRUSH));
1363
1364   double w, h;
1365   GetBoundingBoxMax(&w, &h);
1366   GetEventHandler()->OnDrawOutline(dc, xx, yy, w, h);
1367   m_canvas->CaptureMouse();
1368 }
1369
1370 void wxShape::OnEndDragLeft(double x, double y, int keys, int attachment)
1371 {
1372   m_canvas->ReleaseMouse();
1373   if ((m_sensitivity & OP_DRAG_LEFT) != OP_DRAG_LEFT)
1374   {
1375     attachment = 0;
1376     double dist;
1377     if (m_parent)
1378     {
1379       m_parent->HitTest(x, y, &attachment, &dist);
1380       m_parent->GetEventHandler()->OnEndDragLeft(x, y, keys, attachment);
1381     }
1382     return;
1383   }
1384
1385   wxClientDC dc(GetCanvas());
1386   GetCanvas()->PrepareDC(dc);
1387
1388   dc.SetLogicalFunction(wxCOPY);
1389
1390   double xx = x + DragOffsetX;
1391   double yy = y + DragOffsetY;
1392   m_canvas->Snap(&xx, &yy);
1393 //  canvas->Snap(&m_xpos, &m_ypos);
1394
1395   // New policy: erase shape at end of drag.
1396   Erase(dc);
1397
1398   Move(dc, xx, yy);
1399   if (m_canvas && !m_canvas->GetQuickEditMode()) m_canvas->Redraw(dc);
1400 }
1401
1402 void wxShape::OnDragRight(bool draw, double x, double y, int keys, int attachment)
1403 {
1404   if ((m_sensitivity & OP_DRAG_RIGHT) != OP_DRAG_RIGHT)
1405   {
1406     attachment = 0;
1407     double dist;
1408     if (m_parent)
1409     {
1410       m_parent->HitTest(x, y, &attachment, &dist);
1411       m_parent->GetEventHandler()->OnDragRight(draw, x, y, keys, attachment);
1412     }
1413     return;
1414   }
1415 }
1416
1417 void wxShape::OnBeginDragRight(double x, double y, int keys, int attachment)
1418 {
1419   if ((m_sensitivity & OP_DRAG_RIGHT) != OP_DRAG_RIGHT)
1420   {
1421     attachment = 0;
1422     double dist;
1423     if (m_parent)
1424     {
1425       m_parent->HitTest(x, y, &attachment, &dist);
1426       m_parent->GetEventHandler()->OnBeginDragRight(x, y, keys, attachment);
1427     }
1428     return;
1429   }
1430 }
1431
1432 void wxShape::OnEndDragRight(double x, double y, int keys, int attachment)
1433 {
1434   if ((m_sensitivity & OP_DRAG_RIGHT) != OP_DRAG_RIGHT)
1435   {
1436     attachment = 0;
1437     double dist;
1438     if (m_parent)
1439     {
1440       m_parent->HitTest(x, y, &attachment, &dist);
1441       m_parent->GetEventHandler()->OnEndDragRight(x, y, keys, attachment);
1442     }
1443     return;
1444   }
1445 }
1446
1447 void wxShape::OnDrawOutline(wxDC& dc, double x, double y, double w, double h)
1448 {
1449   double top_left_x = (double)(x - w/2.0);
1450   double top_left_y = (double)(y - h/2.0);
1451   double top_right_x = (double)(top_left_x + w);
1452   double top_right_y = (double)top_left_y;
1453   double bottom_left_x = (double)top_left_x;
1454   double bottom_left_y = (double)(top_left_y + h);
1455   double bottom_right_x = (double)top_right_x;
1456   double bottom_right_y = (double)bottom_left_y;
1457
1458   wxPoint points[5];
1459   points[0].x = WXROUND(top_left_x); points[0].y = WXROUND(top_left_y);
1460   points[1].x = WXROUND(top_right_x); points[1].y = WXROUND(top_right_y);
1461   points[2].x = WXROUND(bottom_right_x); points[2].y = WXROUND(bottom_right_y);
1462   points[3].x = WXROUND(bottom_left_x); points[3].y = WXROUND(bottom_left_y);
1463   points[4].x = WXROUND(top_left_x); points[4].y = WXROUND(top_left_y);
1464
1465   dc.DrawLines(5, points);
1466 }
1467
1468 void wxShape::Attach(wxShapeCanvas *can)
1469 {
1470   m_canvas = can;
1471 }
1472
1473 void wxShape::Detach()
1474 {
1475   m_canvas = NULL;
1476 }
1477
1478 void wxShape::Move(wxDC& dc, double x, double y, bool display)
1479 {
1480   double old_x = m_xpos;
1481   double old_y = m_ypos;
1482
1483   if (!GetEventHandler()->OnMovePre(dc, x, y, old_x, old_y, display))
1484   {
1485 //    m_xpos = old_x;
1486 //    m_ypos = old_y;
1487     return;
1488   }
1489
1490   m_xpos = x; m_ypos = y;
1491
1492   ResetControlPoints();
1493
1494   if (display)
1495     Draw(dc);
1496
1497   MoveLinks(dc);
1498
1499   GetEventHandler()->OnMovePost(dc, x, y, old_x, old_y, display);
1500 }
1501
1502 void wxShape::MoveLinks(wxDC& dc)
1503 {
1504   GetEventHandler()->OnMoveLinks(dc);
1505 }
1506
1507
1508 void wxShape::Draw(wxDC& dc)
1509 {
1510   if (m_visible)
1511   {
1512     GetEventHandler()->OnDraw(dc);
1513     GetEventHandler()->OnDrawContents(dc);
1514     GetEventHandler()->OnDrawControlPoints(dc);
1515     GetEventHandler()->OnDrawBranches(dc);
1516   }
1517 }
1518
1519 void wxShape::Flash()
1520 {
1521     if (GetCanvas())
1522     {
1523         wxClientDC dc(GetCanvas());
1524         GetCanvas()->PrepareDC(dc);
1525
1526         dc.SetLogicalFunction(OGLRBLF);
1527         Draw(dc);
1528         dc.SetLogicalFunction(wxCOPY);
1529         Draw(dc);
1530     }
1531 }
1532
1533 void wxShape::Show(bool show)
1534 {
1535   m_visible = show;
1536   wxNode *node = m_children.GetFirst();
1537   while (node)
1538   {
1539     wxShape *image = (wxShape *)node->GetData();
1540     image->Show(show);
1541     node = node->GetNext();
1542   }
1543 }
1544
1545 void wxShape::Erase(wxDC& dc)
1546 {
1547   GetEventHandler()->OnErase(dc);
1548   GetEventHandler()->OnEraseControlPoints(dc);
1549   GetEventHandler()->OnDrawBranches(dc, true);
1550 }
1551
1552 void wxShape::EraseContents(wxDC& dc)
1553 {
1554   GetEventHandler()->OnEraseContents(dc);
1555 }
1556
1557 void wxShape::AddText(const wxString& string)
1558 {
1559   wxNode *node = m_regions.GetFirst();
1560   if (!node)
1561     return;
1562   wxShapeRegion *region = (wxShapeRegion *)node->GetData();
1563   region->ClearText();
1564   wxShapeTextLine *new_line =
1565       new wxShapeTextLine(0.0, 0.0, string);
1566   region->GetFormattedText().Append(new_line);
1567
1568   m_formatted = false;
1569 }
1570
1571 void wxShape::SetSize(double x, double y, bool WXUNUSED(recursive))
1572 {
1573   SetAttachmentSize(x, y);
1574   SetDefaultRegionSize();
1575 }
1576
1577 void wxShape::SetAttachmentSize(double w, double h)
1578 {
1579   double scaleX;
1580   double scaleY;
1581   double width, height;
1582   GetBoundingBoxMin(&width, &height);
1583   if (width == 0.0)
1584     scaleX = 1.0;
1585   else scaleX = w/width;
1586   if (height == 0.0)
1587     scaleY = 1.0;
1588   else scaleY = h/height;
1589
1590   wxNode *node = m_attachmentPoints.GetFirst();
1591   while (node)
1592   {
1593     wxAttachmentPoint *point = (wxAttachmentPoint *)node->GetData();
1594     point->m_x = (double)(point->m_x * scaleX);
1595     point->m_y = (double)(point->m_y * scaleY);
1596     node = node->GetNext();
1597   }
1598 }
1599
1600 // Add line FROM this object
1601 void wxShape::AddLine(wxLineShape *line, wxShape *other,
1602                             int attachFrom, int attachTo,
1603                             // The line ordering
1604                             int positionFrom, int positionTo)
1605 {
1606     if (positionFrom == -1)
1607     {
1608         if (!m_lines.Member(line))
1609             m_lines.Append(line);
1610     }
1611     else
1612     {
1613         // Don't preserve old ordering if we have new ordering instructions
1614         m_lines.DeleteObject(line);
1615         if (positionFrom < (int) m_lines.GetCount())
1616         {
1617             wxNode* node = m_lines.Item(positionFrom);
1618             m_lines.Insert(node, line);
1619         }
1620         else
1621             m_lines.Append(line);
1622     }
1623
1624     if (positionTo == -1)
1625     {
1626         if (!other->m_lines.Member(line))
1627             other->m_lines.Append(line);
1628     }
1629     else
1630     {
1631         // Don't preserve old ordering if we have new ordering instructions
1632         other->m_lines.DeleteObject(line);
1633         if (positionTo < (int) other->m_lines.GetCount())
1634         {
1635             wxNode* node = other->m_lines.Item(positionTo);
1636             other->m_lines.Insert(node, line);
1637         }
1638         else
1639             other->m_lines.Append(line);
1640     }
1641 #if 0
1642     // Wrong: doesn't preserve ordering of shape already linked
1643     m_lines.DeleteObject(line);
1644     other->m_lines.DeleteObject(line);
1645
1646     if (positionFrom == -1)
1647         m_lines.Append(line);
1648     else
1649     {
1650         if (positionFrom < m_lines.GetCount())
1651         {
1652             wxNode* node = m_lines.Item(positionFrom);
1653             m_lines.Insert(node, line);
1654         }
1655         else
1656             m_lines.Append(line);
1657     }
1658
1659     if (positionTo == -1)
1660         other->m_lines.Append(line);
1661     else
1662     {
1663         if (positionTo < other->m_lines.GetCount())
1664         {
1665             wxNode* node = other->m_lines.Item(positionTo);
1666             other->m_lines.Insert(node, line);
1667         }
1668         else
1669             other->m_lines.Append(line);
1670     }
1671 #endif
1672
1673     line->SetFrom(this);
1674     line->SetTo(other);
1675     line->SetAttachments(attachFrom, attachTo);
1676 }
1677
1678 void wxShape::RemoveLine(wxLineShape *line)
1679 {
1680   if (line->GetFrom() == this)
1681     line->GetTo()->m_lines.DeleteObject(line);
1682   else
1683    line->GetFrom()->m_lines.DeleteObject(line);
1684
1685   m_lines.DeleteObject(line);
1686 }
1687
1688 #if wxUSE_PROLOGIO
1689 void wxShape::WriteAttributes(wxExpr *clause)
1690 {
1691   clause->AddAttributeValueString(_T("type"), GetClassInfo()->GetClassName());
1692   clause->AddAttributeValue(_T("id"), m_id);
1693
1694   if (m_pen)
1695   {
1696     int penWidth = m_pen->GetWidth();
1697     int penStyle = m_pen->GetStyle();
1698     if (penWidth != 1)
1699       clause->AddAttributeValue(_T("pen_width"), (long)penWidth);
1700     if (penStyle != wxSOLID)
1701       clause->AddAttributeValue(_T("pen_style"), (long)penStyle);
1702
1703     wxString penColour = wxTheColourDatabase->FindName(m_pen->GetColour());
1704     if (penColour == wxEmptyString)
1705     {
1706       wxString hex(oglColourToHex(m_pen->GetColour()));
1707       hex = wxString(_T("#")) + hex;
1708       clause->AddAttributeValueString(_T("pen_colour"), hex);
1709     }
1710     else if (penColour != _T("BLACK"))
1711       clause->AddAttributeValueString(_T("pen_colour"), penColour);
1712   }
1713
1714   if (m_brush)
1715   {
1716     wxString brushColour = wxTheColourDatabase->FindName(m_brush->GetColour());
1717
1718     if (brushColour == wxEmptyString)
1719     {
1720       wxString hex(oglColourToHex(m_brush->GetColour()));
1721       hex = wxString(_T("#")) + hex;
1722       clause->AddAttributeValueString(_T("brush_colour"), hex);
1723     }
1724     else if (brushColour != _T("WHITE"))
1725       clause->AddAttributeValueString(_T("brush_colour"), brushColour);
1726
1727     if (m_brush->GetStyle() != wxSOLID)
1728       clause->AddAttributeValue(_T("brush_style"), (long)m_brush->GetStyle());
1729   }
1730
1731   // Output line ids
1732
1733   int n_lines = m_lines.GetCount();
1734   if (n_lines > 0)
1735   {
1736     wxExpr *list = new wxExpr(wxExprList);
1737     wxNode *node = m_lines.GetFirst();
1738     while (node)
1739     {
1740       wxShape *line = (wxShape *)node->GetData();
1741       wxExpr *id_expr = new wxExpr(line->GetId());
1742       list->Append(id_expr);
1743       node = node->GetNext();
1744     }
1745     clause->AddAttributeValue(_T("arcs"), list);
1746   }
1747
1748   // Miscellaneous members
1749   if (m_attachmentMode != 0)
1750     clause->AddAttributeValue(_T("use_attachments"), (long)m_attachmentMode);
1751   if (m_sensitivity != OP_ALL)
1752     clause->AddAttributeValue(_T("sensitivity"), (long)m_sensitivity);
1753   if (!m_spaceAttachments)
1754     clause->AddAttributeValue(_T("space_attachments"), (long)m_spaceAttachments);
1755   if (m_fixedWidth)
1756     clause->AddAttributeValue(_T("fixed_width"), (long)m_fixedWidth);
1757   if (m_fixedHeight)
1758     clause->AddAttributeValue(_T("fixed_height"), (long)m_fixedHeight);
1759   if (m_shadowMode != SHADOW_NONE)
1760     clause->AddAttributeValue(_T("shadow_mode"), (long)m_shadowMode);
1761   if (m_centreResize != true)
1762     clause->AddAttributeValue(_T("centre_resize"), (long)0);
1763   clause->AddAttributeValue(_T("maintain_aspect_ratio"), (long) m_maintainAspectRatio);
1764   if (m_highlighted != false)
1765     clause->AddAttributeValue(_T("hilite"), (long)m_highlighted);
1766
1767   if (m_parent) // For composite objects
1768     clause->AddAttributeValue(_T("parent"), (long)m_parent->GetId());
1769
1770   if (m_rotation != 0.0)
1771     clause->AddAttributeValue(_T("rotation"), m_rotation);
1772
1773   if (!this->IsKindOf(CLASSINFO(wxLineShape)))
1774   {
1775     clause->AddAttributeValue(_T("neck_length"), (long) m_branchNeckLength);
1776     clause->AddAttributeValue(_T("stem_length"), (long) m_branchStemLength);
1777     clause->AddAttributeValue(_T("branch_spacing"), (long) m_branchSpacing);
1778     clause->AddAttributeValue(_T("branch_style"), (long) m_branchStyle);
1779   }
1780
1781   // Write user-defined attachment points, if any
1782   if (m_attachmentPoints.GetCount() > 0)
1783   {
1784     wxExpr *attachmentList = new wxExpr(wxExprList);
1785     wxNode *node = m_attachmentPoints.GetFirst();
1786     while (node)
1787     {
1788       wxAttachmentPoint *point = (wxAttachmentPoint *)node->GetData();
1789       wxExpr *pointExpr = new wxExpr(wxExprList);
1790       pointExpr->Append(new wxExpr((long)point->m_id));
1791       pointExpr->Append(new wxExpr(point->m_x));
1792       pointExpr->Append(new wxExpr(point->m_y));
1793       attachmentList->Append(pointExpr);
1794       node = node->GetNext();
1795     }
1796     clause->AddAttributeValue(_T("user_attachments"), attachmentList);
1797   }
1798
1799   // Write text regions
1800   WriteRegions(clause);
1801 }
1802
1803 void wxShape::WriteRegions(wxExpr *clause)
1804 {
1805   // Output regions as region1 = (...), region2 = (...), etc
1806   // and formatted text as text1 = (...), text2 = (...) etc.
1807   int regionNo = 1;
1808   wxChar regionNameBuf[20];
1809   wxChar textNameBuf[20];
1810   wxNode *node = m_regions.GetFirst();
1811   while (node)
1812   {
1813     wxShapeRegion *region = (wxShapeRegion *)node->GetData();
1814     wxSprintf(regionNameBuf, _T("region%d"), regionNo);
1815     wxSprintf(textNameBuf, _T("text%d"), regionNo);
1816
1817     // Original text and region attributes:
1818     // region1 = (regionName regionText x y width height minWidth minHeight proportionX proportionY
1819     //            formatMode fontSize fontFamily fontStyle fontWeight textColour)
1820     wxExpr *regionExpr = new wxExpr(wxExprList);
1821     regionExpr->Append(new wxExpr(wxExprString, region->m_regionName));
1822     regionExpr->Append(new wxExpr(wxExprString, region->m_regionText));
1823
1824     regionExpr->Append(new wxExpr(region->m_x));
1825     regionExpr->Append(new wxExpr(region->m_y));
1826     regionExpr->Append(new wxExpr(region->GetWidth()));
1827     regionExpr->Append(new wxExpr(region->GetHeight()));
1828
1829     regionExpr->Append(new wxExpr(region->m_minWidth));
1830     regionExpr->Append(new wxExpr(region->m_minHeight));
1831     regionExpr->Append(new wxExpr(region->m_regionProportionX));
1832     regionExpr->Append(new wxExpr(region->m_regionProportionY));
1833
1834     regionExpr->Append(new wxExpr((long)region->m_formatMode));
1835
1836     regionExpr->Append(new wxExpr((long)(region->m_font ? region->m_font->GetPointSize() : 10)));
1837     regionExpr->Append(new wxExpr((long)(region->m_font ? region->m_font->GetFamily() : wxDEFAULT)));
1838     regionExpr->Append(new wxExpr((long)(region->m_font ? region->m_font->GetStyle() : wxDEFAULT)));
1839     regionExpr->Append(new wxExpr((long)(region->m_font ? region->m_font->GetWeight() : wxNORMAL)));
1840     regionExpr->Append(new wxExpr(wxExprString, region->m_textColour));
1841
1842     // New members for pen colour/style
1843     regionExpr->Append(new wxExpr(wxExprString, region->m_penColour));
1844     regionExpr->Append(new wxExpr((long)region->m_penStyle));
1845
1846     // Formatted text:
1847     // text1 = ((x y string) (x y string) ...)
1848     wxExpr *textExpr = new wxExpr(wxExprList);
1849
1850     wxNode *textNode = region->m_formattedText.GetFirst();
1851     while (textNode)
1852     {
1853       wxShapeTextLine *line = (wxShapeTextLine *)textNode->GetData();
1854       wxExpr *list2 = new wxExpr(wxExprList);
1855       list2->Append(new wxExpr(line->GetX()));
1856       list2->Append(new wxExpr(line->GetY()));
1857       list2->Append(new wxExpr(wxExprString, line->GetText()));
1858       textExpr->Append(list2);
1859       textNode = textNode->GetNext();
1860     }
1861
1862     // Now add both attributes to the clause
1863     clause->AddAttributeValue(regionNameBuf, regionExpr);
1864     clause->AddAttributeValue(textNameBuf, textExpr);
1865
1866     node = node->GetNext();
1867     regionNo ++;
1868   }
1869 }
1870
1871 void wxShape::ReadAttributes(wxExpr *clause)
1872 {
1873   clause->GetAttributeValue(_T("id"), m_id);
1874   wxRegisterId(m_id);
1875
1876   clause->GetAttributeValue(_T("x"), m_xpos);
1877   clause->GetAttributeValue(_T("y"), m_ypos);
1878
1879   // Input text strings (FOR COMPATIBILITY WITH OLD FILES ONLY. SEE REGION CODE BELOW.)
1880   ClearText();
1881   wxExpr *strings = clause->AttributeValue(_T("text"));
1882   if (strings && strings->Type() == wxExprList)
1883   {
1884     m_formatted = true;  // Assume text is formatted unless we prove otherwise
1885     wxExpr *node = strings->value.first;
1886     while (node)
1887     {
1888       wxExpr *string_expr = node;
1889       double the_x = 0.0;
1890       double the_y = 0.0;
1891       wxString the_string = wxEmptyString;
1892
1893       // string_expr can either be a string, or a list of
1894       // 3 elements: x, y, and string.
1895       if (string_expr->Type() == wxExprString)
1896       {
1897         the_string = string_expr->StringValue();
1898         m_formatted = false;
1899       }
1900       else if (string_expr->Type() == wxExprList)
1901       {
1902         wxExpr *first = string_expr->value.first;
1903         wxExpr *second = first ? first->next : (wxExpr*) NULL;
1904         wxExpr *third = second ? second->next : (wxExpr*) NULL;
1905
1906         if (first && second && third &&
1907             (first->Type() == wxExprReal || first->Type() == wxExprInteger) &&
1908             (second->Type() == wxExprReal || second->Type() == wxExprInteger) &&
1909             third->Type() == wxExprString)
1910           {
1911             if (first->Type() == wxExprReal)
1912               the_x = first->RealValue();
1913             else the_x = (double)first->IntegerValue();
1914
1915             if (second->Type() == wxExprReal)
1916               the_y = second->RealValue();
1917             else the_y = (double)second->IntegerValue();
1918
1919             the_string = third->StringValue();
1920           }
1921       }
1922       wxShapeTextLine *line =
1923             new wxShapeTextLine(the_x, the_y, the_string);
1924       m_text.Append(line);
1925
1926       node = node->next;
1927     }
1928   }
1929
1930   wxString pen_string = wxEmptyString;
1931   wxString brush_string = wxEmptyString;
1932   int pen_width = 1;
1933   int pen_style = wxSOLID;
1934   int brush_style = wxSOLID;
1935   m_attachmentMode = ATTACHMENT_MODE_NONE;
1936
1937   clause->GetAttributeValue(_T("pen_colour"), pen_string);
1938   clause->GetAttributeValue(_T("text_colour"), m_textColourName);
1939
1940   SetTextColour(m_textColourName);
1941
1942   clause->GetAttributeValue(_T("region_name"), m_regionName);
1943
1944   clause->GetAttributeValue(_T("brush_colour"), brush_string);
1945   clause->GetAttributeValue(_T("pen_width"), pen_width);
1946   clause->GetAttributeValue(_T("pen_style"), pen_style);
1947   clause->GetAttributeValue(_T("brush_style"), brush_style);
1948
1949   int iVal = (int) m_attachmentMode;
1950   clause->GetAttributeValue(_T("use_attachments"), iVal);
1951   m_attachmentMode = iVal;
1952
1953   clause->GetAttributeValue(_T("sensitivity"), m_sensitivity);
1954
1955   iVal = (int) m_spaceAttachments;
1956   clause->GetAttributeValue(_T("space_attachments"), iVal);
1957   m_spaceAttachments = (iVal != 0);
1958
1959   iVal = (int) m_fixedWidth;
1960   clause->GetAttributeValue(_T("fixed_width"), iVal);
1961   m_fixedWidth = (iVal != 0);
1962
1963   iVal = (int) m_fixedHeight;
1964   clause->GetAttributeValue(_T("fixed_height"), iVal);
1965   m_fixedHeight = (iVal != 0);
1966
1967   clause->GetAttributeValue(_T("format_mode"), m_formatMode);
1968   clause->GetAttributeValue(_T("shadow_mode"), m_shadowMode);
1969
1970   iVal = m_branchNeckLength;
1971   clause->GetAttributeValue(_T("neck_length"), iVal);
1972   m_branchNeckLength = iVal;
1973
1974   iVal = m_branchStemLength;
1975   clause->GetAttributeValue(_T("stem_length"), iVal);
1976   m_branchStemLength = iVal;
1977
1978   iVal = m_branchSpacing;
1979   clause->GetAttributeValue(_T("branch_spacing"), iVal);
1980   m_branchSpacing = iVal;
1981
1982   clause->GetAttributeValue(_T("branch_style"), m_branchStyle);
1983
1984   iVal = (int) m_centreResize;
1985   clause->GetAttributeValue(_T("centre_resize"), iVal);
1986   m_centreResize = (iVal != 0);
1987
1988   iVal = (int) m_maintainAspectRatio;
1989   clause->GetAttributeValue(_T("maintain_aspect_ratio"), iVal);
1990   m_maintainAspectRatio = (iVal != 0);
1991
1992   iVal = (int) m_highlighted;
1993   clause->GetAttributeValue(_T("hilite"), iVal);
1994   m_highlighted = (iVal != 0);
1995
1996   clause->GetAttributeValue(_T("rotation"), m_rotation);
1997
1998   if (pen_string == wxEmptyString)
1999     pen_string = _T("BLACK");
2000   if (brush_string == wxEmptyString)
2001     brush_string = _T("WHITE");
2002
2003   if (pen_string.GetChar(0) == '#')
2004   {
2005     wxColour col(oglHexToColour(pen_string.After('#')));
2006     m_pen = wxThePenList->FindOrCreatePen(col, pen_width, pen_style);
2007   }
2008   else
2009     m_pen = wxThePenList->FindOrCreatePen(pen_string, pen_width, pen_style);
2010
2011   if (!m_pen)
2012     m_pen = wxBLACK_PEN;
2013
2014   if (brush_string.GetChar(0) == '#')
2015   {
2016     wxColour col(oglHexToColour(brush_string.After('#')));
2017     m_brush = wxTheBrushList->FindOrCreateBrush(col, brush_style);
2018   }
2019   else
2020     m_brush = wxTheBrushList->FindOrCreateBrush(brush_string, brush_style);
2021
2022   if (!m_brush)
2023     m_brush = wxWHITE_BRUSH;
2024
2025   int point_size = 10;
2026   clause->GetAttributeValue(_T("point_size"), point_size);
2027   SetFont(oglMatchFont(point_size));
2028
2029   // Read user-defined attachment points, if any
2030   wxExpr *attachmentList = clause->AttributeValue(_T("user_attachments"));
2031   if (attachmentList)
2032   {
2033     wxExpr *pointExpr = attachmentList->GetFirst();
2034     while (pointExpr)
2035     {
2036       wxExpr *idExpr = pointExpr->Nth(0);
2037       wxExpr *xExpr = pointExpr->Nth(1);
2038       wxExpr *yExpr = pointExpr->Nth(2);
2039       if (idExpr && xExpr && yExpr)
2040       {
2041         wxAttachmentPoint *point = new wxAttachmentPoint;
2042         point->m_id = (int)idExpr->IntegerValue();
2043         point->m_x = xExpr->RealValue();
2044         point->m_y = yExpr->RealValue();
2045         m_attachmentPoints.Append((wxObject *)point);
2046       }
2047       pointExpr = pointExpr->GetNext();
2048     }
2049   }
2050
2051   // Read text regions
2052   ReadRegions(clause);
2053 }
2054
2055 void wxShape::ReadRegions(wxExpr *clause)
2056 {
2057   ClearRegions();
2058
2059   // region1 = (regionName regionText x y width height minWidth minHeight proportionX proportionY
2060   //            formatMode fontSize fontFamily fontStyle fontWeight textColour)
2061   int regionNo = 1;
2062   wxChar regionNameBuf[20];
2063   wxChar textNameBuf[20];
2064
2065   wxExpr *regionExpr;
2066   wxExpr *textExpr = NULL;
2067   wxSprintf(regionNameBuf, _T("region%d"), regionNo);
2068   wxSprintf(textNameBuf, _T("text%d"), regionNo);
2069
2070   m_formatted = true;  // Assume text is formatted unless we prove otherwise
2071
2072   while ((regionExpr = clause->AttributeValue(regionNameBuf)) != NULL)
2073   {
2074     /*
2075      * Get the region information
2076      *
2077      */
2078
2079     wxString regionName = wxEmptyString;
2080     wxString regionText = wxEmptyString;
2081     double x = 0.0;
2082     double y = 0.0;
2083     double width = 0.0;
2084     double height = 0.0;
2085     double minWidth = 5.0;
2086     double minHeight = 5.0;
2087     double m_regionProportionX = -1.0;
2088     double m_regionProportionY = -1.0;
2089     int formatMode = FORMAT_NONE;
2090     int fontSize = 10;
2091     int fontFamily = wxSWISS;
2092     int fontStyle = wxNORMAL;
2093     int fontWeight = wxNORMAL;
2094     wxString regionTextColour = wxEmptyString;
2095     wxString penColour = wxEmptyString;
2096     int penStyle = wxSOLID;
2097
2098     if (regionExpr->Type() == wxExprList)
2099     {
2100       wxExpr *nameExpr = regionExpr->Nth(0);
2101       wxExpr *textExpr = regionExpr->Nth(1);
2102       wxExpr *xExpr = regionExpr->Nth(2);
2103       wxExpr *yExpr = regionExpr->Nth(3);
2104       wxExpr *widthExpr = regionExpr->Nth(4);
2105       wxExpr *heightExpr = regionExpr->Nth(5);
2106       wxExpr *minWidthExpr = regionExpr->Nth(6);
2107       wxExpr *minHeightExpr = regionExpr->Nth(7);
2108       wxExpr *propXExpr = regionExpr->Nth(8);
2109       wxExpr *propYExpr = regionExpr->Nth(9);
2110       wxExpr *formatExpr = regionExpr->Nth(10);
2111       wxExpr *sizeExpr = regionExpr->Nth(11);
2112       wxExpr *familyExpr = regionExpr->Nth(12);
2113       wxExpr *styleExpr = regionExpr->Nth(13);
2114       wxExpr *weightExpr = regionExpr->Nth(14);
2115       wxExpr *colourExpr = regionExpr->Nth(15);
2116       wxExpr *penColourExpr = regionExpr->Nth(16);
2117       wxExpr *penStyleExpr = regionExpr->Nth(17);
2118
2119       regionName = nameExpr->StringValue();
2120       regionText = textExpr->StringValue();
2121
2122       x = xExpr->RealValue();
2123       y = yExpr->RealValue();
2124
2125       width = widthExpr->RealValue();
2126       height = heightExpr->RealValue();
2127
2128       minWidth = minWidthExpr->RealValue();
2129       minHeight = minHeightExpr->RealValue();
2130
2131       m_regionProportionX = propXExpr->RealValue();
2132       m_regionProportionY = propYExpr->RealValue();
2133
2134       formatMode = (int) formatExpr->IntegerValue();
2135       fontSize = (int)sizeExpr->IntegerValue();
2136       fontFamily = (int)familyExpr->IntegerValue();
2137       fontStyle = (int)styleExpr->IntegerValue();
2138       fontWeight = (int)weightExpr->IntegerValue();
2139
2140       if (colourExpr)
2141       {
2142         regionTextColour = colourExpr->StringValue();
2143       }
2144       else
2145         regionTextColour = _T("BLACK");
2146
2147       if (penColourExpr)
2148         penColour = penColourExpr->StringValue();
2149       if (penStyleExpr)
2150         penStyle = (int)penStyleExpr->IntegerValue();
2151     }
2152     wxFont *font = wxTheFontList->FindOrCreateFont(fontSize, fontFamily, fontStyle, fontWeight);
2153
2154     wxShapeRegion *region = new wxShapeRegion;
2155     region->SetProportions(m_regionProportionX, m_regionProportionY);
2156     region->SetFont(font);
2157     region->SetSize(width, height);
2158     region->SetPosition(x, y);
2159     region->SetMinSize(minWidth, minHeight);
2160     region->SetFormatMode(formatMode);
2161     region->SetPenStyle(penStyle);
2162     if (penColour != wxEmptyString)
2163       region->SetPenColour(penColour);
2164
2165     region->m_textColour = regionTextColour;
2166     region->m_regionText = regionText;
2167     region->m_regionName = regionName;
2168
2169     m_regions.Append(region);
2170
2171     /*
2172      * Get the formatted text strings
2173      *
2174      */
2175     textExpr = clause->AttributeValue(textNameBuf);
2176     if (textExpr && (textExpr->Type() == wxExprList))
2177     {
2178       wxExpr *node = textExpr->value.first;
2179       while (node)
2180       {
2181         wxExpr *string_expr = node;
2182         double the_x = 0.0;
2183         double the_y = 0.0;
2184         wxString the_string = wxEmptyString;
2185
2186         // string_expr can either be a string, or a list of
2187         // 3 elements: x, y, and string.
2188         if (string_expr->Type() == wxExprString)
2189         {
2190           the_string = string_expr->StringValue();
2191           m_formatted = false;
2192         }
2193         else if (string_expr->Type() == wxExprList)
2194         {
2195           wxExpr *first = string_expr->value.first;
2196           wxExpr *second = first ? first->next : (wxExpr*) NULL;
2197           wxExpr *third = second ? second->next : (wxExpr*) NULL;
2198
2199           if (first && second && third &&
2200               (first->Type() == wxExprReal || first->Type() == wxExprInteger) &&
2201               (second->Type() == wxExprReal || second->Type() == wxExprInteger) &&
2202               third->Type() == wxExprString)
2203           {
2204             if (first->Type() == wxExprReal)
2205               the_x = first->RealValue();
2206             else the_x = (double)first->IntegerValue();
2207
2208             if (second->Type() == wxExprReal)
2209               the_y = second->RealValue();
2210             else the_y = (double)second->IntegerValue();
2211
2212             the_string = third->StringValue();
2213           }
2214         }
2215         if (the_string)
2216         {
2217           wxShapeTextLine *line =
2218               new wxShapeTextLine(the_x, the_y, the_string);
2219           region->m_formattedText.Append(line);
2220         }
2221         node = node->next;
2222       }
2223     }
2224
2225     regionNo ++;
2226     wxSprintf(regionNameBuf, _T("region%d"), regionNo);
2227     wxSprintf(textNameBuf, _T("text%d"), regionNo);
2228   }
2229
2230   // Compatibility: check for no regions (old file).
2231   // Lines and divided rectangles must deal with this compatibility
2232   // theirselves. Composites _may_ not have any regions anyway.
2233   if ((m_regions.GetCount() == 0) &&
2234       !this->IsKindOf(CLASSINFO(wxLineShape)) && !this->IsKindOf(CLASSINFO(wxDividedShape)) &&
2235       !this->IsKindOf(CLASSINFO(wxCompositeShape)))
2236   {
2237     wxShapeRegion *newRegion = new wxShapeRegion;
2238     newRegion->SetName(_T("0"));
2239     m_regions.Append((wxObject *)newRegion);
2240     if (m_text.GetCount() > 0)
2241     {
2242       newRegion->ClearText();
2243       wxNode *node = m_text.GetFirst();
2244       while (node)
2245       {
2246         wxShapeTextLine *textLine = (wxShapeTextLine *)node->GetData();
2247         wxNode *next = node->GetNext();
2248         newRegion->GetFormattedText().Append((wxObject *)textLine);
2249         delete node;
2250         node = next;
2251       }
2252     }
2253   }
2254 }
2255
2256 #endif
2257
2258 void wxShape::Copy(wxShape& copy)
2259 {
2260   copy.m_id = m_id;
2261   copy.m_xpos = m_xpos;
2262   copy.m_ypos = m_ypos;
2263   copy.m_pen = m_pen;
2264   copy.m_brush = m_brush;
2265   copy.m_textColour = m_textColour;
2266   copy.m_centreResize = m_centreResize;
2267   copy.m_maintainAspectRatio = m_maintainAspectRatio;
2268   copy.m_attachmentMode = m_attachmentMode;
2269   copy.m_spaceAttachments = m_spaceAttachments;
2270   copy.m_highlighted = m_highlighted;
2271   copy.m_rotation = m_rotation;
2272   copy.m_textColourName = m_textColourName;
2273   copy.m_regionName = m_regionName;
2274
2275   copy.m_sensitivity = m_sensitivity;
2276   copy.m_draggable = m_draggable;
2277   copy.m_fixedWidth = m_fixedWidth;
2278   copy.m_fixedHeight = m_fixedHeight;
2279   copy.m_formatMode = m_formatMode;
2280   copy.m_drawHandles = m_drawHandles;
2281
2282   copy.m_visible = m_visible;
2283   copy.m_shadowMode = m_shadowMode;
2284   copy.m_shadowOffsetX = m_shadowOffsetX;
2285   copy.m_shadowOffsetY = m_shadowOffsetY;
2286   copy.m_shadowBrush = m_shadowBrush;
2287
2288   copy.m_branchNeckLength = m_branchNeckLength;
2289   copy.m_branchStemLength = m_branchStemLength;
2290   copy.m_branchSpacing = m_branchSpacing;
2291
2292   // Copy text regions
2293   copy.ClearRegions();
2294   wxNode *node = m_regions.GetFirst();
2295   while (node)
2296   {
2297     wxShapeRegion *region = (wxShapeRegion *)node->GetData();
2298     wxShapeRegion *newRegion = new wxShapeRegion(*region);
2299     copy.m_regions.Append(newRegion);
2300     node = node->GetNext();
2301   }
2302
2303   // Copy attachments
2304   copy.ClearAttachments();
2305   node = m_attachmentPoints.GetFirst();
2306   while (node)
2307   {
2308     wxAttachmentPoint *point = (wxAttachmentPoint *)node->GetData();
2309     wxAttachmentPoint *newPoint = new wxAttachmentPoint;
2310     newPoint->m_id = point->m_id;
2311     newPoint->m_x = point->m_x;
2312     newPoint->m_y = point->m_y;
2313     copy.m_attachmentPoints.Append((wxObject *)newPoint);
2314     node = node->GetNext();
2315   }
2316
2317   // Copy lines
2318   copy.m_lines.Clear();
2319   node = m_lines.GetFirst();
2320   while (node)
2321   {
2322     wxLineShape* line = (wxLineShape*) node->GetData();
2323     copy.m_lines.Append(line);
2324     node = node->GetNext();
2325   }
2326 }
2327
2328 // Create and return a new, fully copied object.
2329 wxShape *wxShape::CreateNewCopy(bool resetMapping, bool recompute)
2330 {
2331   if (resetMapping)
2332     oglObjectCopyMapping.Clear();
2333
2334   wxShape* newObject = (wxShape*) GetClassInfo()->CreateObject();
2335
2336   wxASSERT( (newObject != NULL) );
2337   wxASSERT( (newObject->IsKindOf(CLASSINFO(wxShape))) );
2338
2339   Copy(*newObject);
2340
2341   if (GetEventHandler() != this)
2342   {
2343     wxShapeEvtHandler* newHandler = GetEventHandler()->CreateNewCopy();
2344     newObject->SetEventHandler(newHandler);
2345     newObject->SetPreviousHandler(NULL);
2346     newHandler->SetPreviousHandler(newObject);
2347     newHandler->SetShape(newObject);
2348   }
2349
2350   if (recompute)
2351     newObject->Recompute();
2352   return newObject;
2353 }
2354
2355 // Does the copying for this object, including copying event
2356 // handler data if any. Calls the virtual Copy function.
2357 void wxShape::CopyWithHandler(wxShape& copy)
2358 {
2359     Copy(copy);
2360
2361     if (GetEventHandler() != this)
2362     {
2363         wxASSERT( copy.GetEventHandler() != NULL );
2364         wxASSERT( copy.GetEventHandler() != (&copy) );
2365         wxASSERT( GetEventHandler()->GetClassInfo() == copy.GetEventHandler()->GetClassInfo() );
2366         GetEventHandler()->CopyData(* (copy.GetEventHandler()));
2367     }
2368 }
2369
2370
2371 // Default - make 6 control points
2372 void wxShape::MakeControlPoints()
2373 {
2374   double maxX, maxY, minX, minY;
2375
2376   GetBoundingBoxMax(&maxX, &maxY);
2377   GetBoundingBoxMin(&minX, &minY);
2378
2379   double widthMin = (double)(minX + CONTROL_POINT_SIZE + 2);
2380   double heightMin = (double)(minY + CONTROL_POINT_SIZE + 2);
2381
2382   // Offsets from main object
2383   double top = (double)(- (heightMin / 2.0));
2384   double bottom = (double)(heightMin / 2.0 + (maxY - minY));
2385   double left = (double)(- (widthMin / 2.0));
2386   double right = (double)(widthMin / 2.0 + (maxX - minX));
2387
2388   wxControlPoint *control = new wxControlPoint(m_canvas, this, CONTROL_POINT_SIZE, left, top,
2389                                            CONTROL_POINT_DIAGONAL);
2390   m_canvas->AddShape(control);
2391   m_controlPoints.Append(control);
2392
2393   control = new wxControlPoint(m_canvas, this, CONTROL_POINT_SIZE, 0, top,
2394                                            CONTROL_POINT_VERTICAL);
2395   m_canvas->AddShape(control);
2396   m_controlPoints.Append(control);
2397
2398   control = new wxControlPoint(m_canvas, this, CONTROL_POINT_SIZE, right, top,
2399                                            CONTROL_POINT_DIAGONAL);
2400   m_canvas->AddShape(control);
2401   m_controlPoints.Append(control);
2402
2403   control = new wxControlPoint(m_canvas, this, CONTROL_POINT_SIZE, right, 0,
2404                                            CONTROL_POINT_HORIZONTAL);
2405   m_canvas->AddShape(control);
2406   m_controlPoints.Append(control);
2407
2408   control = new wxControlPoint(m_canvas, this, CONTROL_POINT_SIZE, right, bottom,
2409                                            CONTROL_POINT_DIAGONAL);
2410   m_canvas->AddShape(control);
2411   m_controlPoints.Append(control);
2412
2413   control = new wxControlPoint(m_canvas, this, CONTROL_POINT_SIZE, 0, bottom,
2414                                            CONTROL_POINT_VERTICAL);
2415   m_canvas->AddShape(control);
2416   m_controlPoints.Append(control);
2417
2418   control = new wxControlPoint(m_canvas, this, CONTROL_POINT_SIZE, left, bottom,
2419                                            CONTROL_POINT_DIAGONAL);
2420   m_canvas->AddShape(control);
2421   m_controlPoints.Append(control);
2422
2423   control = new wxControlPoint(m_canvas, this, CONTROL_POINT_SIZE, left, 0,
2424                                            CONTROL_POINT_HORIZONTAL);
2425   m_canvas->AddShape(control);
2426   m_controlPoints.Append(control);
2427
2428 }
2429
2430 void wxShape::MakeMandatoryControlPoints()
2431 {
2432   wxNode *node = m_children.GetFirst();
2433   while (node)
2434   {
2435     wxShape *child = (wxShape *)node->GetData();
2436     child->MakeMandatoryControlPoints();
2437     node = node->GetNext();
2438   }
2439 }
2440
2441 void wxShape::ResetMandatoryControlPoints()
2442 {
2443   wxNode *node = m_children.GetFirst();
2444   while (node)
2445   {
2446     wxShape *child = (wxShape *)node->GetData();
2447     child->ResetMandatoryControlPoints();
2448     node = node->GetNext();
2449   }
2450 }
2451
2452 void wxShape::ResetControlPoints()
2453 {
2454   ResetMandatoryControlPoints();
2455
2456   if (m_controlPoints.GetCount() < 1)
2457     return;
2458
2459   double maxX, maxY, minX, minY;
2460
2461   GetBoundingBoxMax(&maxX, &maxY);
2462   GetBoundingBoxMin(&minX, &minY);
2463
2464   double widthMin = (double)(minX + CONTROL_POINT_SIZE + 2);
2465   double heightMin = (double)(minY + CONTROL_POINT_SIZE + 2);
2466
2467   // Offsets from main object
2468   double top = (double)(- (heightMin / 2.0));
2469   double bottom = (double)(heightMin / 2.0 + (maxY - minY));
2470   double left = (double)(- (widthMin / 2.0));
2471   double right = (double)(widthMin / 2.0 + (maxX - minX));
2472
2473   wxNode *node = m_controlPoints.GetFirst();
2474   wxControlPoint *control = (wxControlPoint *)node->GetData();
2475   control->m_xoffset = left; control->m_yoffset = top;
2476
2477   node = node->GetNext(); control = (wxControlPoint *)node->GetData();
2478   control->m_xoffset = 0; control->m_yoffset = top;
2479
2480   node = node->GetNext(); control = (wxControlPoint *)node->GetData();
2481   control->m_xoffset = right; control->m_yoffset = top;
2482
2483   node = node->GetNext(); control = (wxControlPoint *)node->GetData();
2484   control->m_xoffset = right; control->m_yoffset = 0;
2485
2486   node = node->GetNext(); control = (wxControlPoint *)node->GetData();
2487   control->m_xoffset = right; control->m_yoffset = bottom;
2488
2489   node = node->GetNext(); control = (wxControlPoint *)node->GetData();
2490   control->m_xoffset = 0; control->m_yoffset = bottom;
2491
2492   node = node->GetNext(); control = (wxControlPoint *)node->GetData();
2493   control->m_xoffset = left; control->m_yoffset = bottom;
2494
2495   node = node->GetNext(); control = (wxControlPoint *)node->GetData();
2496   control->m_xoffset = left; control->m_yoffset = 0;
2497 }
2498
2499 void wxShape::DeleteControlPoints(wxDC *dc)
2500 {
2501   wxNode *node = m_controlPoints.GetFirst();
2502   while (node)
2503   {
2504     wxControlPoint *control = (wxControlPoint *)node->GetData();
2505     if (dc)
2506         control->GetEventHandler()->OnErase(*dc);
2507     m_canvas->RemoveShape(control);
2508     delete control;
2509     delete node;
2510     node = m_controlPoints.GetFirst();
2511   }
2512   // Children of divisions are contained objects,
2513   // so stop here
2514   if (!IsKindOf(CLASSINFO(wxDivisionShape)))
2515   {
2516     node = m_children.GetFirst();
2517     while (node)
2518     {
2519       wxShape *child = (wxShape *)node->GetData();
2520       child->DeleteControlPoints(dc);
2521       node = node->GetNext();
2522     }
2523   }
2524 }
2525
2526 void wxShape::OnDrawControlPoints(wxDC& dc)
2527 {
2528   if (!m_drawHandles)
2529     return;
2530
2531   dc.SetBrush(* wxBLACK_BRUSH);
2532   dc.SetPen(* wxBLACK_PEN);
2533
2534   wxNode *node = m_controlPoints.GetFirst();
2535   while (node)
2536   {
2537     wxControlPoint *control = (wxControlPoint *)node->GetData();
2538     control->Draw(dc);
2539     node = node->GetNext();
2540   }
2541   // Children of divisions are contained objects,
2542   // so stop here.
2543   // This test bypasses the type facility for speed
2544   // (critical when drawing)
2545   if (!IsKindOf(CLASSINFO(wxDivisionShape)))
2546   {
2547     node = m_children.GetFirst();
2548     while (node)
2549     {
2550       wxShape *child = (wxShape *)node->GetData();
2551       child->GetEventHandler()->OnDrawControlPoints(dc);
2552       node = node->GetNext();
2553     }
2554   }
2555 }
2556
2557 void wxShape::OnEraseControlPoints(wxDC& dc)
2558 {
2559   wxNode *node = m_controlPoints.GetFirst();
2560   while (node)
2561   {
2562     wxControlPoint *control = (wxControlPoint *)node->GetData();
2563     control->Erase(dc);
2564     node = node->GetNext();
2565   }
2566   if (!IsKindOf(CLASSINFO(wxDivisionShape)))
2567   {
2568     node = m_children.GetFirst();
2569     while (node)
2570     {
2571       wxShape *child = (wxShape *)node->GetData();
2572       child->GetEventHandler()->OnEraseControlPoints(dc);
2573       node = node->GetNext();
2574     }
2575   }
2576 }
2577
2578 void wxShape::Select(bool select, wxDC* dc)
2579 {
2580   m_selected = select;
2581   if (select)
2582   {
2583     MakeControlPoints();
2584     // Children of divisions are contained objects,
2585     // so stop here
2586     if (!IsKindOf(CLASSINFO(wxDivisionShape)))
2587     {
2588       wxNode *node = m_children.GetFirst();
2589       while (node)
2590       {
2591         wxShape *child = (wxShape *)node->GetData();
2592         child->MakeMandatoryControlPoints();
2593         node = node->GetNext();
2594       }
2595     }
2596     if (dc)
2597         GetEventHandler()->OnDrawControlPoints(*dc);
2598   }
2599   if (!select)
2600   {
2601     DeleteControlPoints(dc);
2602     if (!IsKindOf(CLASSINFO(wxDivisionShape)))
2603     {
2604       wxNode *node = m_children.GetFirst();
2605       while (node)
2606       {
2607         wxShape *child = (wxShape *)node->GetData();
2608         child->DeleteControlPoints(dc);
2609         node = node->GetNext();
2610       }
2611     }
2612   }
2613 }
2614
2615 bool wxShape::Selected() const
2616 {
2617   return m_selected;
2618 }
2619
2620 bool wxShape::AncestorSelected() const
2621 {
2622   if (m_selected) return true;
2623   if (!GetParent())
2624     return false;
2625   else
2626     return GetParent()->AncestorSelected();
2627 }
2628
2629 int wxShape::GetNumberOfAttachments() const
2630 {
2631   // Should return the MAXIMUM attachment point id here,
2632   // so higher-level functions can iterate through all attachments,
2633   // even if they're not contiguous.
2634   if (m_attachmentPoints.GetCount() == 0)
2635     return 4;
2636   else
2637   {
2638     int maxN = 3;
2639     wxNode *node = m_attachmentPoints.GetFirst();
2640     while (node)
2641     {
2642       wxAttachmentPoint *point = (wxAttachmentPoint *)node->GetData();
2643       if (point->m_id > maxN)
2644         maxN = point->m_id;
2645       node = node->GetNext();
2646     }
2647     return maxN+1;;
2648   }
2649 }
2650
2651 bool wxShape::AttachmentIsValid(int attachment) const
2652 {
2653   if (m_attachmentPoints.GetCount() == 0)
2654   {
2655     return ((attachment >= 0) && (attachment < 4)) ;
2656   }
2657
2658   wxNode *node = m_attachmentPoints.GetFirst();
2659   while (node)
2660   {
2661     wxAttachmentPoint *point = (wxAttachmentPoint *)node->GetData();
2662     if (point->m_id == attachment)
2663       return true;
2664     node = node->GetNext();
2665   }
2666   return false;
2667 }
2668
2669 bool wxShape::GetAttachmentPosition(int attachment, double *x, double *y,
2670                                          int nth, int no_arcs, wxLineShape *line)
2671 {
2672     if (m_attachmentMode == ATTACHMENT_MODE_NONE)
2673     {
2674         *x = m_xpos; *y = m_ypos;
2675         return true;
2676     }
2677     else if (m_attachmentMode == ATTACHMENT_MODE_BRANCHING)
2678     {
2679         wxRealPoint pt, stemPt;
2680         GetBranchingAttachmentPoint(attachment, nth, pt, stemPt);
2681         *x = pt.x;
2682         *y = pt.y;
2683         return true;
2684     }
2685     else if (m_attachmentMode == ATTACHMENT_MODE_EDGE)
2686     {
2687         if (m_attachmentPoints.GetCount() > 0)
2688         {
2689             wxNode *node = m_attachmentPoints.GetFirst();
2690             while (node)
2691             {
2692                 wxAttachmentPoint *point = (wxAttachmentPoint *)node->GetData();
2693                 if (point->m_id == attachment)
2694                 {
2695                     *x = (double)(m_xpos + point->m_x);
2696                     *y = (double)(m_ypos + point->m_y);
2697                     return true;
2698                 }
2699                 node = node->GetNext();
2700             }
2701             *x = m_xpos; *y = m_ypos;
2702             return false;
2703         }
2704         else
2705         {
2706             // Assume is rectangular
2707             double w, h;
2708             GetBoundingBoxMax(&w, &h);
2709             double top = (double)(m_ypos + h/2.0);
2710             double bottom = (double)(m_ypos - h/2.0);
2711             double left = (double)(m_xpos - w/2.0);
2712             double right = (double)(m_xpos + w/2.0);
2713
2714             /* bool isEnd = */ (line && line->IsEnd(this));
2715
2716             int physicalAttachment = LogicalToPhysicalAttachment(attachment);
2717
2718             // Simplified code
2719             switch (physicalAttachment)
2720             {
2721                 case 0:
2722                 {
2723                     wxRealPoint pt = CalcSimpleAttachment(wxRealPoint(left, bottom), wxRealPoint(right, bottom),
2724                             nth, no_arcs, line);
2725
2726                     *x = pt.x; *y = pt.y;
2727                     break;
2728                 }
2729                 case 1:
2730                 {
2731                     wxRealPoint pt = CalcSimpleAttachment(wxRealPoint(right, bottom), wxRealPoint(right, top),
2732                             nth, no_arcs, line);
2733
2734                     *x = pt.x; *y = pt.y;
2735                     break;
2736                 }
2737                 case 2:
2738                 {
2739                     wxRealPoint pt = CalcSimpleAttachment(wxRealPoint(left, top), wxRealPoint(right, top),
2740                             nth, no_arcs, line);
2741
2742                     *x = pt.x; *y = pt.y;
2743                     break;
2744                 }
2745                 case 3:
2746                 {
2747                     wxRealPoint pt = CalcSimpleAttachment(wxRealPoint(left, bottom), wxRealPoint(left, top),
2748                             nth, no_arcs, line);
2749
2750                     *x = pt.x; *y = pt.y;
2751                     break;
2752                 }
2753                 default:
2754                 {
2755                     return false;
2756                 }
2757             }
2758             return true;
2759         }
2760     }
2761     return false;
2762 }
2763
2764 void wxShape::GetBoundingBoxMax(double *w, double *h)
2765 {
2766   double ww, hh;
2767   GetBoundingBoxMin(&ww, &hh);
2768   if (m_shadowMode != SHADOW_NONE)
2769   {
2770     ww += m_shadowOffsetX;
2771     hh += m_shadowOffsetY;
2772   }
2773   *w = ww;
2774   *h = hh;
2775 }
2776
2777 // Returns true if image is a descendant of this composite
2778 bool wxShape::HasDescendant(wxShape *image)
2779 {
2780   if (image == this)
2781     return true;
2782   wxNode *node = m_children.GetFirst();
2783   while (node)
2784   {
2785     wxShape *child = (wxShape *)node->GetData();
2786     bool ans = child->HasDescendant(image);
2787     if (ans)
2788       return true;
2789     node = node->GetNext();
2790   }
2791   return false;
2792 }
2793
2794 // Clears points from a list of wxRealPoints, and clears list
2795 void wxShape::ClearPointList(wxList& list)
2796 {
2797     wxNode* node = list.GetFirst();
2798     while (node)
2799     {
2800         wxRealPoint* pt = (wxRealPoint*) node->GetData();
2801         delete pt;
2802
2803         node = node->GetNext();
2804     }
2805     list.Clear();
2806 }
2807
2808 // Assuming the attachment lies along a vertical or horizontal line,
2809 // calculate the position on that point.
2810 wxRealPoint wxShape::CalcSimpleAttachment(const wxRealPoint& pt1, const wxRealPoint& pt2,
2811     int nth, int noArcs, wxLineShape* line)
2812 {
2813     bool isEnd = (line && line->IsEnd(this));
2814
2815     // Are we horizontal or vertical?
2816     bool isHorizontal = (oglRoughlyEqual(pt1.y, pt2.y) == true);
2817
2818     double x, y;
2819
2820     if (isHorizontal)
2821     {
2822         wxRealPoint firstPoint, secondPoint;
2823         if (pt1.x > pt2.x)
2824         {
2825             firstPoint = pt2;
2826             secondPoint = pt1;
2827         }
2828         else
2829         {
2830             firstPoint = pt1;
2831             secondPoint = pt2;
2832         }
2833
2834         if (m_spaceAttachments)
2835         {
2836           if (line && (line->GetAlignmentType(isEnd) == LINE_ALIGNMENT_TO_NEXT_HANDLE))
2837           {
2838             // Align line according to the next handle along
2839             wxRealPoint *point = line->GetNextControlPoint(this);
2840             if (point->x < firstPoint.x)
2841               x = firstPoint.x;
2842             else if (point->x > secondPoint.x)
2843               x = secondPoint.x;
2844             else
2845               x = point->x;
2846           }
2847           else
2848             x = firstPoint.x + (nth + 1)*(secondPoint.x - firstPoint.x)/(noArcs + 1);
2849         }
2850         else x = (secondPoint.x - firstPoint.x)/2.0; // Midpoint
2851
2852         y = pt1.y;
2853     }
2854     else
2855     {
2856         wxASSERT( oglRoughlyEqual(pt1.x, pt2.x) == true );
2857
2858         wxRealPoint firstPoint, secondPoint;
2859         if (pt1.y > pt2.y)
2860         {
2861             firstPoint = pt2;
2862             secondPoint = pt1;
2863         }
2864         else
2865         {
2866             firstPoint = pt1;
2867             secondPoint = pt2;
2868         }
2869
2870         if (m_spaceAttachments)
2871         {
2872           if (line && (line->GetAlignmentType(isEnd) == LINE_ALIGNMENT_TO_NEXT_HANDLE))
2873           {
2874             // Align line according to the next handle along
2875             wxRealPoint *point = line->GetNextControlPoint(this);
2876             if (point->y < firstPoint.y)
2877               y = firstPoint.y;
2878             else if (point->y > secondPoint.y)
2879               y = secondPoint.y;
2880             else
2881               y = point->y;
2882           }
2883           else
2884             y = firstPoint.y + (nth + 1)*(secondPoint.y - firstPoint.y)/(noArcs + 1);
2885         }
2886         else y = (secondPoint.y - firstPoint.y)/2.0; // Midpoint
2887
2888         x = pt1.x;
2889     }
2890
2891     return wxRealPoint(x, y);
2892 }
2893
2894 // Return the zero-based position in m_lines of line.
2895 int wxShape::GetLinePosition(wxLineShape* line)
2896 {
2897     for (size_t i = 0; i < m_lines.GetCount(); i++)
2898         if ((wxLineShape*) (m_lines.Item(i)->GetData()) == line)
2899             return i;
2900
2901     return 0;
2902 }
2903
2904 //
2905 //             |________|
2906 //                 | <- root
2907 //                 | <- neck
2908 // shoulder1 ->---------<- shoulder2
2909 //             | | | | |
2910 //                      <- branching attachment point N-1
2911
2912 // This function gets information about where branching connections go.
2913 // Returns false if there are no lines at this attachment.
2914 bool wxShape::GetBranchingAttachmentInfo(int attachment, wxRealPoint& root, wxRealPoint& neck,
2915     wxRealPoint& shoulder1, wxRealPoint& shoulder2)
2916 {
2917     int physicalAttachment = LogicalToPhysicalAttachment(attachment);
2918
2919     // Number of lines at this attachment.
2920     int lineCount = GetAttachmentLineCount(attachment);
2921
2922     if (lineCount == 0)
2923         return false;
2924
2925     int totalBranchLength = m_branchSpacing * (lineCount - 1);
2926
2927     root = GetBranchingAttachmentRoot(attachment);
2928
2929     // Assume that we have attachment points 0 to 3: top, right, bottom, left.
2930     switch (physicalAttachment)
2931     {
2932         case 0:
2933         {
2934             neck.x = GetX();
2935             neck.y = root.y - m_branchNeckLength;
2936
2937             shoulder1.x = root.x - (totalBranchLength/2.0) ;
2938             shoulder2.x = root.x + (totalBranchLength/2.0) ;
2939
2940             shoulder1.y = neck.y;
2941             shoulder2.y = neck.y;
2942             break;
2943         }
2944         case 1:
2945         {
2946             neck.x = root.x + m_branchNeckLength;
2947             neck.y = root.y;
2948
2949             shoulder1.x = neck.x ;
2950             shoulder2.x = neck.x ;
2951
2952             shoulder1.y = neck.y - (totalBranchLength/2.0) ;
2953             shoulder2.y = neck.y + (totalBranchLength/2.0) ;
2954             break;
2955         }
2956         case 2:
2957         {
2958             neck.x = GetX();
2959             neck.y = root.y + m_branchNeckLength;
2960
2961             shoulder1.x = root.x - (totalBranchLength/2.0) ;
2962             shoulder2.x = root.x + (totalBranchLength/2.0) ;
2963
2964             shoulder1.y = neck.y;
2965             shoulder2.y = neck.y;
2966             break;
2967         }
2968         case 3:
2969         {
2970             neck.x = root.x - m_branchNeckLength;
2971             neck.y = root.y ;
2972
2973             shoulder1.x = neck.x ;
2974             shoulder2.x = neck.x ;
2975
2976             shoulder1.y = neck.y - (totalBranchLength/2.0) ;
2977             shoulder2.y = neck.y + (totalBranchLength/2.0) ;
2978             break;
2979         }
2980         default:
2981         {
2982             wxFAIL_MSG( wxT("Unrecognised attachment point in GetBranchingAttachmentInfo.") );
2983             break;
2984         }
2985     }
2986     return true;
2987 }
2988
2989 // n is the number of the adjoining line, from 0 to N-1 where N is the number of lines
2990 // at this attachment point.
2991 // Get the attachment point where the arc joins the stem, and also the point where the
2992 // the stem meets the shoulder.
2993 bool wxShape::GetBranchingAttachmentPoint(int attachment, int n, wxRealPoint& pt, wxRealPoint& stemPt)
2994 {
2995     int physicalAttachment = LogicalToPhysicalAttachment(attachment);
2996
2997     wxRealPoint root, neck, shoulder1, shoulder2;
2998     GetBranchingAttachmentInfo(attachment, root, neck, shoulder1, shoulder2);
2999
3000     // Assume that we have attachment points 0 to 3: top, right, bottom, left.
3001     switch (physicalAttachment)
3002     {
3003         case 0:
3004         {
3005             pt.y = neck.y - m_branchStemLength;
3006             pt.x = shoulder1.x + n*m_branchSpacing;
3007
3008             stemPt.x = pt.x;
3009             stemPt.y = neck.y;
3010             break;
3011         }
3012         case 2:
3013         {
3014             pt.y = neck.y + m_branchStemLength;
3015             pt.x = shoulder1.x + n*m_branchSpacing;
3016
3017             stemPt.x = pt.x;
3018             stemPt.y = neck.y;
3019             break;
3020         }
3021         case 1:
3022         {
3023             pt.x = neck.x + m_branchStemLength;
3024             pt.y = shoulder1.y + n*m_branchSpacing;
3025
3026             stemPt.x = neck.x;
3027             stemPt.y = pt.y;
3028             break;
3029         }
3030         case 3:
3031         {
3032             pt.x = neck.x - m_branchStemLength;
3033             pt.y = shoulder1.y + n*m_branchSpacing;
3034
3035             stemPt.x = neck.x;
3036             stemPt.y = pt.y;
3037             break;
3038         }
3039         default:
3040         {
3041             wxFAIL_MSG( wxT("Unrecognised attachment point in GetBranchingAttachmentPoint.") );
3042             break;
3043         }
3044     }
3045
3046     return true;
3047 }
3048
3049 // Get the number of lines at this attachment position.
3050 int wxShape::GetAttachmentLineCount(int attachment) const
3051 {
3052     int count = 0;
3053     wxNode* node = m_lines.GetFirst();
3054     while (node)
3055     {
3056         wxLineShape* lineShape = (wxLineShape*) node->GetData();
3057         if ((lineShape->GetFrom() == this) && (lineShape->GetAttachmentFrom() == attachment))
3058             count ++;
3059         else if ((lineShape->GetTo() == this) && (lineShape->GetAttachmentTo() == attachment))
3060             count ++;
3061
3062         node = node->GetNext();
3063     }
3064     return count;
3065 }
3066
3067 // This function gets the root point at the given attachment.
3068 wxRealPoint wxShape::GetBranchingAttachmentRoot(int attachment)
3069 {
3070     int physicalAttachment = LogicalToPhysicalAttachment(attachment);
3071
3072     wxRealPoint root;
3073
3074     double width, height;
3075     GetBoundingBoxMax(& width, & height);
3076
3077     // Assume that we have attachment points 0 to 3: top, right, bottom, left.
3078     switch (physicalAttachment)
3079     {
3080         case 0:
3081         {
3082             root.x = GetX() ;
3083             root.y = GetY() - height/2.0;
3084             break;
3085         }
3086         case 1:
3087         {
3088             root.x = GetX() + width/2.0;
3089             root.y = GetY() ;
3090             break;
3091         }
3092         case 2:
3093         {
3094             root.x = GetX() ;
3095             root.y = GetY() + height/2.0;
3096             break;
3097         }
3098         case 3:
3099         {
3100             root.x = GetX() - width/2.0;
3101             root.y = GetY() ;
3102             break;
3103         }
3104         default:
3105         {
3106             wxFAIL_MSG( wxT("Unrecognised attachment point in GetBranchingAttachmentRoot.") );
3107             break;
3108         }
3109     }
3110     return root;
3111 }
3112
3113 // Draw or erase the branches (not the actual arcs though)
3114 void wxShape::OnDrawBranches(wxDC& dc, int attachment, bool erase)
3115 {
3116     int count = GetAttachmentLineCount(attachment);
3117     if (count == 0)
3118         return;
3119
3120     wxRealPoint root, neck, shoulder1, shoulder2;
3121     GetBranchingAttachmentInfo(attachment, root, neck, shoulder1, shoulder2);
3122
3123     if (erase)
3124     {
3125         dc.SetPen(*wxWHITE_PEN);
3126         dc.SetBrush(*wxWHITE_BRUSH);
3127     }
3128     else
3129     {
3130         dc.SetPen(*wxBLACK_PEN);
3131         dc.SetBrush(*wxBLACK_BRUSH);
3132     }
3133
3134     // Draw neck
3135     dc.DrawLine((long) root.x, (long) root.y, (long) neck.x, (long) neck.y);
3136
3137     if (count > 1)
3138     {
3139         // Draw shoulder-to-shoulder line
3140         dc.DrawLine((long) shoulder1.x, (long) shoulder1.y, (long) shoulder2.x, (long) shoulder2.y);
3141     }
3142     // Draw all the little branches
3143     int i;
3144     for (i = 0; i < count; i++)
3145     {
3146         wxRealPoint pt, stemPt;
3147         GetBranchingAttachmentPoint(attachment, i, pt, stemPt);
3148         dc.DrawLine((long) stemPt.x, (long) stemPt.y, (long) pt.x, (long) pt.y);
3149
3150         if ((GetBranchStyle() & BRANCHING_ATTACHMENT_BLOB) && (count > 1))
3151         {
3152             long blobSize=6;
3153 //            dc.DrawEllipse((long) (stemPt.x + 0.5 - (blobSize/2.0)), (long) (stemPt.y + 0.5 - (blobSize/2.0)), blobSize, blobSize);
3154             dc.DrawEllipse((long) (stemPt.x - (blobSize/2.0)), (long) (stemPt.y - (blobSize/2.0)), blobSize, blobSize);
3155         }
3156     }
3157 }
3158
3159 // Draw or erase the branches (not the actual arcs though)
3160 void wxShape::OnDrawBranches(wxDC& dc, bool erase)
3161 {
3162     if (m_attachmentMode != ATTACHMENT_MODE_BRANCHING)
3163         return;
3164
3165     int count = GetNumberOfAttachments();
3166     int i;
3167     for (i = 0; i < count; i++)
3168         OnDrawBranches(dc, i, erase);
3169 }
3170
3171 // Only get the attachment position at the _edge_ of the shape, ignoring
3172 // branching mode. This is used e.g. to indicate the edge of interest, not the point
3173 // on the attachment branch.
3174 bool wxShape::GetAttachmentPositionEdge(int attachment, double *x, double *y,
3175                                      int nth, int no_arcs, wxLineShape *line)
3176 {
3177     int oldMode = m_attachmentMode;
3178
3179     // Calculate as if to edge, not branch
3180     if (m_attachmentMode == ATTACHMENT_MODE_BRANCHING)
3181         m_attachmentMode = ATTACHMENT_MODE_EDGE;
3182     bool success = GetAttachmentPosition(attachment, x, y, nth, no_arcs, line);
3183     m_attachmentMode = oldMode;
3184
3185     return success;
3186 }
3187
3188 // Rotate the standard attachment point from physical (0 is always North)
3189 // to logical (0 -> 1 if rotated by 90 degrees)
3190 int wxShape::PhysicalToLogicalAttachment(int physicalAttachment) const
3191 {
3192     const double pi = M_PI ;
3193     int i;
3194     if (oglRoughlyEqual(GetRotation(), 0.0))
3195     {
3196         i = physicalAttachment;
3197     }
3198     else if (oglRoughlyEqual(GetRotation(), (pi/2.0)))
3199     {
3200         i = physicalAttachment - 1;
3201     }
3202     else if (oglRoughlyEqual(GetRotation(), pi))
3203     {
3204         i = physicalAttachment - 2;
3205     }
3206     else if (oglRoughlyEqual(GetRotation(), (3.0*pi/2.0)))
3207     {
3208         i = physicalAttachment - 3;
3209     }
3210     else
3211         // Can't handle -- assume the same.
3212         return physicalAttachment;
3213
3214     if (i < 0)
3215       i += 4;
3216
3217     return i;
3218 }
3219
3220 // Rotate the standard attachment point from logical
3221 // to physical (0 is always North)
3222 int wxShape::LogicalToPhysicalAttachment(int logicalAttachment) const
3223 {
3224     const double pi = M_PI ;
3225     int i;
3226     if (oglRoughlyEqual(GetRotation(), 0.0))
3227     {
3228         i = logicalAttachment;
3229     }
3230     else if (oglRoughlyEqual(GetRotation(), (pi/2.0)))
3231     {
3232         i = logicalAttachment + 1;
3233     }
3234     else if (oglRoughlyEqual(GetRotation(), pi))
3235     {
3236         i = logicalAttachment + 2;
3237     }
3238     else if (oglRoughlyEqual(GetRotation(), (3.0*pi/2.0)))
3239     {
3240         i = logicalAttachment + 3;
3241     }
3242     else
3243         // Can't handle -- assume the same.
3244         return logicalAttachment;
3245
3246     if (i > 3)
3247       i -= 4;
3248
3249     return i;
3250 }
3251
3252 void wxShape::Rotate(double WXUNUSED(x), double WXUNUSED(y), double theta)
3253 {
3254     const double pi = M_PI ;
3255     m_rotation = theta;
3256     if (m_rotation < 0.0)
3257     {
3258         m_rotation += 2*pi;
3259     }
3260     else if (m_rotation > 2*pi)
3261     {
3262         m_rotation -= 2*pi;
3263     }
3264 }
3265
3266
3267 wxPen wxShape::GetBackgroundPen()
3268 {
3269     if (GetCanvas())
3270     {
3271         wxColour c = GetCanvas()->GetBackgroundColour();
3272         return wxPen(c, 1, wxSOLID);
3273     }
3274     return * g_oglWhiteBackgroundPen;
3275 }
3276
3277
3278 wxBrush wxShape::GetBackgroundBrush()
3279 {
3280     if (GetCanvas())
3281     {
3282         wxColour c = GetCanvas()->GetBackgroundColour();
3283         return wxBrush(c, wxSOLID);
3284     }
3285     return * g_oglWhiteBackgroundBrush;
3286 }
3287