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