wxPython/wx/lib/ogl/lines.py

   1 # -*- coding: iso-8859-1 -*-
   2 #----------------------------------------------------------------------------
   3 # Name:         lines.py
   4 # Purpose:      LineShape class
   5 #
   6 # Author:       Pierre Hjälm (from C++ original by Julian Smart)
   7 #
   8 # Created:      2004-05-08
   9 # RCS-ID:       $Id$
  10 # Copyright:    (c) 2004 Pierre Hjälm - 1998 Julian Smart
  11 # Licence:      wxWindows license
  12 #----------------------------------------------------------------------------
  13
  14 from __future__ import division
  15
  16 import sys
  17
  18 from math import sqrt
  19
  20 from basic import Shape, ShapeRegion, ControlPoint, RectangleShape
  21 from oglmisc import *
  22
  23 # Line alignment flags
  24 # Vertical by default
  25 LINE_ALIGNMENT_HORIZ=              1
  26 LINE_ALIGNMENT_VERT=               0
  27 LINE_ALIGNMENT_TO_NEXT_HANDLE=     2
  28 LINE_ALIGNMENT_NONE=               0
  29
  30
  31
  32 class LineControlPoint(ControlPoint):
  33     def __init__(self, theCanvas = None, object = None, size = 0.0, x = 0.0, y = 0.0, the_type = 0):
  34         ControlPoint.__init__(self, theCanvas, object, size, x, y, the_type)
  35         self._xpos = x
  36         self._ypos = y
  37         self._type = the_type
  38         self._point = None
  39         self._originalPos = None
  40
  41     def OnDraw(self, dc):
  42         RectangleShape.OnDraw(self, dc)
  43
  44     # Implement movement of Line point
  45     def OnDragLeft(self, draw, x, y, keys = 0, attachment = 0):
  46         self._shape.GetEventHandler().OnSizingDragLeft(self, draw, x, y, keys, attachment)
  47
  48     def OnBeginDragLeft(self, x, y, keys = 0, attachment = 0):
  49         self._shape.GetEventHandler().OnSizingBeginDragLeft(self, x, y, keys, attachment)
  50
  51     def OnEndDragLeft(self, x, y, keys = 0, attachment = 0):
  52         self._shape.GetEventHandler().OnSizingEndDragLeft(self, x, y, keys, attachment)
  53
  54
  55
  56 class ArrowHead(object):
  57     def __init__(self, type = 0, end = 0, size = 0.0, dist = 0.0, name="",mf = None, arrowId=-1):
  58         if isinstance(type, ArrowHead):
  59             pass
  60         else:
  61             self._arrowType = type
  62             self._arrowEnd = end
  63             self._arrowSize = size
  64             self._xOffset = dist
  65             self._yOffset = 0.0
  66             self._spacing = 5.0
  67
  68             self._arrowName = name
  69             self._metaFile = mf
  70             self._id = arrowId
  71             if self._id==-1:
  72                 self._id = wx.NewId()
  73
  74     def _GetType(self):
  75         return self._arrowType
  76
  77     def GetPosition(self):
  78         return self._arrowEnd
  79
  80     def SetPosition(self, pos):
  81         self._arrowEnd = pos
  82
  83     def GetXOffset(self):
  84         return self._xOffset
  85
  86     def GetYOffset(self):
  87         return self._yOffset
  88
  89     def GetSpacing(self):
  90         return self._spacing
  91
  92     def GetSize(self):
  93         return self._arrowSize
  94
  95     def SetSize(self, size):
  96         self._arrowSize = size
  97         if self._arrowType == ARROW_METAFILE and self._metaFile:
  98             oldWidth = self._metaFile._width
  99             if oldWidth == 0:
 100                 return
 101
 102             scale = size / oldWidth
 103             if scale != 1:
 104                 self._metaFile.Scale(scale, scale)
 105
 106     def GetName(self):
 107         return self._arrowName
 108
 109     def SetXOffset(self, x):
 110         self._xOffset = x
 111
 112     def SetYOffset(self, y):
 113         self._yOffset = y
 114
 115     def GetMetaFile(self):
 116         return self._metaFile
 117
 118     def GetId(self):
 119         return self._id
 120
 121     def GetArrowEnd(self):
 122         return self._arrowEnd
 123
 124     def GetArrowSize(self):
 125         return self._arrowSize
 126
 127     def SetSpacing(self, sp):
 128         self._spacing = sp
 129
 130
 131
 132 class LabelShape(RectangleShape):
 133     def __init__(self, parent, region, w, h):
 134         RectangleShape.__init__(self, w, h)
 135         self._lineShape = parent
 136         self._shapeRegion = region
 137         self.SetPen(wx.ThePenList.FindOrCreatePen(wx.Colour(0, 0, 0), 1, wx.DOT))
 138
 139     def OnDraw(self, dc):
 140         if self._lineShape and not self._lineShape.GetDrawHandles():
 141             return
 142
 143         x1 = self._xpos-self._width / 2
 144         y1 = self._ypos-self._height / 2
 145
 146         if self._pen:
 147             if self._pen.GetWidth() == 0:
 148                 dc.SetPen(wx.Pen(wx.WHITE, 1, wx.TRANSPARENT))
 149             else:
 150                 dc.SetPen(self._pen)
 151         dc.SetBrush(wx.TRANSPARENT_BRUSH)
 152
 153         if self._cornerRadius>0:
 154             dc.DrawRoundedRectangle(x1, y1, self._width, self._height, self._cornerRadius)
 155         else:
 156             dc.DrawRectangle(x1, y1, self._width, self._height)
 157
 158     def OnDrawContents(self, dc):
 159         pass
 160
 161     def OnDragLeft(self, draw, x, y, keys = 0, attachment = 0):
 162         RectangleShape.OnDragLeft(self, draw, x, y, keys, attachment)
 163
 164     def OnBeginDragLeft(self, x, y, keys = 0, attachment = 0):
 165         RectangleShape.OnBeginDragLeft(self, x, y, keys, attachment)
 166
 167     def OnEndDragLeft(self, x, y, keys = 0, attachment = 0):
 168         RectangleShape.OnEndDragLeft(self, x, y, keys, attachment)
 169
 170     def OnMovePre(self, dc, x, y, old_x, old_y, display):
 171         return self._lineShape.OnLabelMovePre(dc, self, x, y, old_x, old_y, display)
 172
 173     # Divert left and right clicks to line object
 174     def OnLeftClick(self, x, y, keys = 0, attachment = 0):
 175         self._lineShape.GetEventHandler().OnLeftClick(x, y, keys, attachment)
 176
 177     def OnRightClick(self, x, y, keys = 0, attachment = 0):
 178         self._lineShape.GetEventHandler().OnRightClick(x, y, keys, attachment)
 179
 180
 181
 182 class LineShape(Shape):
 183     """LineShape may be attached to two nodes;
 184     it may be segmented, in which case a control point is drawn for each joint.
 185
 186     A wxLineShape may have arrows at the beginning, end and centre.
 187
 188     Derived from:
 189       Shape
 190     """
 191     def __init__(self):
 192         Shape.__init__(self)
 193
 194         self._sensitivity = OP_CLICK_LEFT | OP_CLICK_RIGHT
 195         self._draggable = False
 196         self._attachmentTo = 0
 197         self._attachmentFrom = 0
 198         self._from = None
 199         self._to = None
 200         self._erasing = False
 201         self._arrowSpacing = 5.0
 202         self._ignoreArrowOffsets = False
 203         self._isSpline = False
 204         self._maintainStraightLines = False
 205         self._alignmentStart = 0
 206         self._alignmentEnd = 0
 207
 208         self._lineControlPoints = None
 209
 210         # Clear any existing regions (created in an earlier constructor)
 211         # and make the three line regions.
 212         self.ClearRegions()
 213         for name in ["Middle","Start","End"]:
 214             newRegion = ShapeRegion()
 215             newRegion.SetName(name)
 216             newRegion.SetSize(150, 50)
 217             self._regions.append(newRegion)
 218
 219         self._labelObjects = [None, None, None]
 220         self._lineOrientations = []
 221         self._lineControlPoints = []
 222         self._arcArrows = []
 223
 224     def __del__(self):
 225         if self._lineControlPoints:
 226             self.ClearPointList(self._lineControlPoints)
 227             self._lineControlPoints = []
 228         for i in range(3):
 229             if self._labelObjects[i]:
 230                 self._labelObjects[i].Select(False)
 231                 self._labelObjects[i].RemoveFromCanvas(self._canvas)
 232         self._labelObjects = []
 233         self.ClearArrowsAtPosition(-1)
 234
 235     def GetFrom(self):
 236         """Return the 'from' object."""
 237         return self._from
 238
 239     def GetTo(self):
 240         """Return the 'to' object."""
 241         return self._to
 242
 243     def GetAttachmentFrom(self):
 244         """Return the attachment point on the 'from' node."""
 245         return self._attachmentFrom
 246
 247     def GetAttachmentTo(self):
 248         """Return the attachment point on the 'to' node."""
 249         return self._attachmentTo
 250
 251     def GetLineControlPoints(self):
 252         return self._lineControlPoints
 253
 254     def SetSpline(self, spline):
 255         """Specifies whether a spline is to be drawn through the control points."""
 256         self._isSpline = spline
 257
 258     def IsSpline(self):
 259         """TRUE if a spline is drawn through the control points."""
 260         return self._isSpline
 261
 262     def SetAttachmentFrom(self, attach):
 263         """Set the 'from' shape attachment."""
 264         self._attachmentFrom = attach
 265
 266     def SetAttachmentTo(self, attach):
 267         """Set the 'to' shape attachment."""
 268         self._attachmentTo = attach
 269
 270     # This is really to distinguish between lines and other images.
 271     # For lines, want to pass drag to canvas, since lines tend to prevent
 272     # dragging on a canvas (they get in the way.)
 273     def Draggable(self):
 274         return False
 275
 276     def SetIgnoreOffsets(self, ignore):
 277         """Set whether to ignore offsets from the end of the line when drawing."""
 278         self._ignoreArrowOffsets = ignore
 279
 280     def GetArrows(self):
 281         return self._arcArrows
 282
 283     def GetAlignmentStart(self):
 284         return self._alignmentStart
 285
 286     def GetAlignmentEnd(self):
 287         return self._alignmentEnd
 288
 289     def IsEnd(self, nodeObject):
 290         """TRUE if shape is at the end of the line."""
 291         return self._to == nodeObject
 292
 293     def MakeLineControlPoints(self, n):
 294         """Make a given number of control points (minimum of two)."""
 295         if self._lineControlPoints:
 296             self.ClearPointList(self._lineControlPoints)
 297         self._lineControlPoints = []
 298
 299         for _ in range(n):
 300             point = wx.RealPoint(-999,-999)
 301             self._lineControlPoints.append(point)
 302
 303     def InsertLineControlPoint(self, dc = None):
 304         """Insert a control point at an arbitrary position."""
 305         if dc:
 306             self.Erase(dc)
 307
 308         last_point = self._lineControlPoints[-1]
 309         second_last_point = self._lineControlPoints[-2]
 310
 311         line_x = (last_point[0] + second_last_point[0]) / 2
 312         line_y = (last_point[1] + second_last_point[1]) / 2
 313
 314         point = wx.RealPoint(line_x, line_y)
 315         self._lineControlPoints.insert(len(self._lineControlPoints), point)
 316
 317     def DeleteLineControlPoint(self):
 318         """Delete an arbitary point on the line."""
 319         if len(self._lineControlPoints)<3:
 320             return False
 321
 322         del self._lineControlPoints[-2]
 323         return True
 324
 325     def Initialise(self):
 326         """Initialise the line object."""
 327         if self._lineControlPoints:
 328             # Just move the first and last control points
 329             first_point = self._lineControlPoints[0]
 330             last_point = self._lineControlPoints[-1]
 331
 332             # If any of the line points are at -999, we must
 333             # initialize them by placing them half way between the first
 334             # and the last.
 335
 336             for point in self._lineControlPoints[1:]:
 337                 if point[0]==-999:
 338                     if first_point[0]<last_point[0]:
 339                         x1 = first_point[0]
 340                         x2 = last_point[0]
 341                     else:
 342                         x2 = first_point[0]
 343                         x1 = last_point[0]
 344                     if first_point[1]<last_point[1]:
 345                         y1 = first_point[1]
 346                         y2 = last_point[1]
 347                     else:
 348                         y2 = first_point[1]
 349                         y1 = last_point[1]
 350                     point[0] = (x2-x1) / 2 + x1
 351                     point[1] = (y2-y1) / 2 + y1
 352
 353     def FormatText(self, dc, s, i):
 354         """Format a text string according to the region size, adding
 355         strings with positions to region text list.
 356         """
 357         self.ClearText(i)
 358
 359         if len(self._regions) == 0 or i >= len(self._regions):
 360             return
 361
 362         region = self._regions[i]
 363         region.SetText(s)
 364         dc.SetFont(region.GetFont())
 365
 366         w, h = region.GetSize()
 367         # Initialize the size if zero
 368         if (w == 0 or h == 0) and s:
 369             w, h = 100, 50
 370             region.SetSize(w, h)
 371
 372         string_list = FormatText(dc, s, w-5, h-5, region.GetFormatMode())
 373         for s in string_list:
 374             line = ShapeTextLine(0.0, 0.0, s)
 375             region.GetFormattedText().append(line)
 376
 377         actualW = w
 378         actualH = h
 379         if region.GetFormatMode() & FORMAT_SIZE_TO_CONTENTS:
 380             actualW, actualH = GetCentredTextExtent(dc, region.GetFormattedText(), self._xpos, self._ypos, w, h)
 381             if actualW != w or actualH != h:
 382                 xx, yy = self.GetLabelPosition(i)
 383                 self.EraseRegion(dc, region, xx, yy)
 384                 if len(self._labelObjects)<i:
 385                     self._labelObjects[i].Select(False, dc)
 386                     self._labelObjects[i].Erase(dc)
 387                     self._labelObjects[i].SetSize(actualW, actualH)
 388
 389                 region.SetSize(actualW, actualH)
 390
 391                 if len(self._labelObjects)<i:
 392                     self._labelObjects[i].Select(True, dc)
 393                     self._labelObjects[i].Draw(dc)
 394
 395         CentreText(dc, region.GetFormattedText(), self._xpos, self._ypos, actualW, actualH, region.GetFormatMode())
 396         self._formatted = True
 397
 398     def DrawRegion(self, dc, region, x, y):
 399         """Format one region at this position."""
 400         if self.GetDisableLabel():
 401             return
 402
 403         w, h = region.GetSize()
 404
 405         # Get offset from x, y
 406         xx, yy = region.GetPosition()
 407
 408         xp = xx + x
 409         yp = yy + y
 410
 411         # First, clear a rectangle for the text IF there is any
 412         if len(region.GetFormattedText()):
 413             dc.SetPen(self.GetBackgroundPen())
 414             dc.SetBrush(self.GetBackgroundBrush())
 415
 416             # Now draw the text
 417             if region.GetFont():
 418                 dc.SetFont(region.GetFont())
 419                 dc.DrawRectangle(xp-w / 2, yp-h / 2, w, h)
 420
 421                 if self._pen:
 422                     dc.SetPen(self._pen)
 423                 dc.SetTextForeground(region.GetActualColourObject())
 424
 425                 DrawFormattedText(dc, region.GetFormattedText(), xp, yp, w, h, region.GetFormatMode())
 426
 427     def EraseRegion(self, dc, region, x, y):
 428         """Erase one region at this position."""
 429         if self.GetDisableLabel():
 430             return
 431
 432         w, h = region.GetSize()
 433
 434         # Get offset from x, y
 435         xx, yy = region.GetPosition()
 436
 437         xp = xx + x
 438         yp = yy + y
 439
 440         if region.GetFormattedText():
 441             dc.SetPen(self.GetBackgroundPen())
 442             dc.SetBrush(self.GetBackgroundBrush())
 443
 444             dc.DrawRectangle(xp-w / 2, yp-h / 2, w, h)
 445
 446     def GetLabelPosition(self, position):
 447         """Get the reference point for a label.
 448
 449         Region x and y are offsets from this.
 450         position is 0 (middle), 1 (start), 2 (end).
 451         """
 452         if position == 0:
 453             # Want to take the middle section for the label
 454             half_way = int(len(self._lineControlPoints) / 2)
 455
 456             # Find middle of this line
 457             point = self._lineControlPoints[half_way-1]
 458             next_point = self._lineControlPoints[half_way]
 459
 460             dx = next_point[0]-point[0]
 461             dy = next_point[1]-point[1]
 462
 463             return point[0] + dx / 2, point[1] + dy / 2
 464         elif position == 1:
 465             return self._lineControlPoints[0][0], self._lineControlPoints[0][1]
 466         elif position == 2:
 467             return self._lineControlPoints[-1][0], self._lineControlPoints[-1][1]
 468
 469     def Straighten(self, dc = None):
 470         """Straighten verticals and horizontals."""
 471         if len(self._lineControlPoints)<3:
 472             return
 473
 474         if dc:
 475             self.Erase(dc)
 476
 477         GraphicsStraightenLine(self._lineControlPoints[-1], self._lineControlPoints[-2])
 478
 479         for i in range(len(self._lineControlPoints)-2):
 480             GraphicsStraightenLine(self._lineControlPoints[i], self._lineControlPoints[i + 1])
 481
 482         if dc:
 483             self.Draw(dc)
 484
 485     def Unlink(self):
 486         """Unlink the line from the nodes at either end."""
 487         if self._to:
 488             self._to.GetLines().remove(self)
 489         if self._from:
 490             self._from.GetLines().remove(self)
 491         self._to = None
 492         self._from = None
 493
 494     def SetEnds(self, x1, y1, x2, y2):
 495         """Set the end positions of the line."""
 496         # Find centre point
 497         first_point = self._lineControlPoints[0]
 498         last_point = self._lineControlPoints[-1]
 499
 500         first_point[0] = x1
 501         first_point[1] = y1
 502         last_point[0] = x2
 503         last_point[1] = y2
 504
 505         self._xpos = (x1 + x2) / 2
 506         self._ypos = (y1 + y2) / 2
 507
 508     # Get absolute positions of ends
 509     def GetEnds(self):
 510         """Get the visible endpoints of the lines for drawing between two objects."""
 511         first_point = self._lineControlPoints[0]
 512         last_point = self._lineControlPoints[-1]
 513
 514         return (first_point[0], first_point[1]), (last_point[0], last_point[1])
 515
 516     def SetAttachments(self, from_attach, to_attach):
 517         """Specify which object attachment points should be used at each end
 518         of the line.
 519         """
 520         self._attachmentFrom = from_attach
 521         self._attachmentTo = to_attach
 522
 523     def HitTest(self, x, y):
 524         if not self._lineControlPoints:
 525             return False
 526
 527         # Look at label regions in case mouse is over a label
 528         inLabelRegion = False
 529         for i in range(3):
 530             if self._regions[i]:
 531                 region = self._regions[i]
 532                 if len(region._formattedText):
 533                     xp, yp = self.GetLabelPosition(i)
 534                     # Offset region from default label position
 535                     cx, cy = region.GetPosition()
 536                     cw, ch = region.GetSize()
 537                     cx += xp
 538                     cy += yp
 539
 540                     rLeft = cx-cw / 2
 541                     rTop = cy-ch / 2
 542                     rRight = cx + cw / 2
 543                     rBottom = cy + ch / 2
 544                     if x>rLeft and x<rRight and y>rTop and y<rBottom:
 545                         inLabelRegion = True
 546                         break
 547
 548         for i in range(len(self._lineControlPoints)-1):
 549             point1 = self._lineControlPoints[i]
 550             point2 = self._lineControlPoints[i + 1]
 551
 552             # For inaccurate mousing allow 8 pixel corridor
 553             extra = 4
 554
 555             dx = point2[0]-point1[0]
 556             dy = point2[1]-point1[1]
 557
 558             seg_len = sqrt(dx * dx + dy * dy)
 559             if dy == 0 or dx == 0:
 560                 return False
 561             distance_from_seg = seg_len * ((x-point1[0]) * dy-(y-point1[1]) * dx) / (dy * dy + dx * dx)
 562             distance_from_prev = seg_len * ((y-point1[1]) * dy + (x-point1[0]) * dx) / (dy * dy + dx * dx)
 563
 564             if abs(distance_from_seg)<extra and distance_from_prev >= 0 and distance_from_prev <= seg_len or inLabelRegion:
 565                 return 0, distance_from_seg
 566
 567         return False
 568
 569     def DrawArrows(self, dc):
 570         """Draw all arrows."""
 571         # Distance along line of each arrow: space them out evenly
 572         startArrowPos = 0.0
 573         endArrowPos = 0.0
 574         middleArrowPos = 0.0
 575
 576         for arrow in self._arcArrows:
 577             ah = arrow.GetArrowEnd()
 578             if ah == ARROW_POSITION_START:
 579                 if arrow.GetXOffset() and not self._ignoreArrowOffsets:
 580                     # If specified, x offset is proportional to line length
 581                     self.DrawArrow(dc, arrow, arrow.GetXOffset(), True)
 582                 else:
 583                     self.DrawArrow(dc, arrow, startArrowPos, False)
 584                     startArrowPos += arrow.GetSize() + arrow.GetSpacing()
 585             elif ah == ARROW_POSITION_END:
 586                 if arrow.GetXOffset() and not self._ignoreArrowOffsets:
 587                     self.DrawArrow(dc, arrow, arrow.GetXOffset(), True)
 588                 else:
 589                     self.DrawArrow(dc, arrow, endArrowPos, False)
 590                     endArrowPos += arrow.GetSize() + arrow.GetSpacing()
 591             elif ah == ARROW_POSITION_MIDDLE:
 592                 arrow.SetXOffset(middleArrowPos)
 593                 if arrow.GetXOffset() and not self._ignoreArrowOffsets:
 594                     self.DrawArrow(dc, arrow, arrow.GetXOffset(), True)
 595                 else:
 596                     self.DrawArrow(dc, arrow, middleArrowPos, False)
 597                     middleArrowPos += arrow.GetSize() + arrow.GetSpacing()
 598
 599     def DrawArrow(self, dc, arrow, XOffset, proportionalOffset):
 600         """Draw the given arrowhead (or annotation)."""
 601         first_line_point = self._lineControlPoints[0]
 602         second_line_point = self._lineControlPoints[1]
 603
 604         last_line_point = self._lineControlPoints[-1]
 605         second_last_line_point = self._lineControlPoints[-2]
 606
 607         # Position of start point of line, at the end of which we draw the arrow
 608         startPositionX, startPositionY = 0.0, 0.0
 609
 610         ap = arrow.GetPosition()
 611         if ap == ARROW_POSITION_START:
 612             # If we're using a proportional offset, calculate just where this
 613             # will be on the line.
 614             realOffset = XOffset
 615             if proportionalOffset:
 616                 totalLength = sqrt((second_line_point[0]-first_line_point[0]) * (second_line_point[0]-first_line_point[0]) + (second_line_point[1]-first_line_point[1]) * (second_line_point[1]-first_line_point[1]))
 617                 realOffset = XOffset * totalLength
 618
 619             positionOnLineX, positionOnLineY = GetPointOnLine(second_line_point[0], second_line_point[1], first_line_point[0], first_line_point[1], realOffset)
 620
 621             startPositionX = second_line_point[0]
 622             startPositionY = second_line_point[1]
 623         elif ap == ARROW_POSITION_END:
 624             # If we're using a proportional offset, calculate just where this
 625             # will be on the line.
 626             realOffset = XOffset
 627             if proportionalOffset:
 628                 totalLength = sqrt((second_last_line_point[0]-last_line_point[0]) * (second_last_line_point[0]-last_line_point[0]) + (second_last_line_point[1]-last_line_point[1]) * (second_last_line_point[1]-last_line_point[1]));
 629                 realOffset = XOffset * totalLength
 630
 631             positionOnLineX, positionOnLineY = GetPointOnLine(second_last_line_point[0], second_last_line_point[1], last_line_point[0], last_line_point[1], realOffset)
 632
 633             startPositionX = second_last_line_point[0]
 634             startPositionY = second_last_line_point[1]
 635         elif ap == ARROW_POSITION_MIDDLE:
 636             # Choose a point half way between the last and penultimate points
 637             x = (last_line_point[0] + second_last_line_point[0]) / 2
 638             y = (last_line_point[1] + second_last_line_point[1]) / 2
 639
 640             # If we're using a proportional offset, calculate just where this
 641             # will be on the line.
 642             realOffset = XOffset
 643             if proportionalOffset:
 644                 totalLength = sqrt((second_last_line_point[0]-x) * (second_last_line_point[0]-x) + (second_last_line_point[1]-y) * (second_last_line_point[1]-y));
 645                 realOffset = XOffset * totalLength
 646
 647             positionOnLineX, positionOnLineY = GetPointOnLine(second_last_line_point[0], second_last_line_point[1], x, y, realOffset)
 648             startPositionX = second_last_line_point[0]
 649             startPositionY = second_last_line_point[1]
 650
 651         # Add yOffset to arrow, if any
 652
 653         # The translation that the y offset may give
 654         deltaX = 0.0
 655         deltaY = 0.0
 656         if arrow.GetYOffset and not self._ignoreArrowOffsets:
 657             #                             |(x4, y4)
 658             #                             |d
 659             #                             |
 660             #   (x1, y1)--------------(x3, y3)------------------(x2, y2)
 661             #   x4 = x3 - d * sin(theta)
 662             #   y4 = y3 + d * cos(theta)
 663             #
 664             #   Where theta = tan(-1) of (y3-y1) / (x3-x1)
 665             x1 = startPositionX
 666             y1 = startPositionY
 667             x3 = positionOnLineX
 668             y3 = positionOnLineY
 669             d=-arrow.GetYOffset() # Negate so +offset is above line
 670
 671             if x3 == x1:
 672                 theta = pi / 2
 673             else:
 674                 theta = atan((y3-y1) / (x3-x1))
 675
 676             x4 = x3-d * sin(theta)
 677             y4 = y3 + d * cos(theta)
 678
 679             deltaX = x4-positionOnLineX
 680             deltaY = y4-positionOnLineY
 681
 682         at = arrow._GetType()
 683         if at == ARROW_ARROW:
 684             arrowLength = arrow.GetSize()
 685             arrowWidth = arrowLength / 3
 686
 687             tip_x, tip_y, side1_x, side1_y, side2_x, side2_y = GetArrowPoints(startPositionX + deltaX, startPositionY + deltaY, positionOnLineX + deltaX, positionOnLineY + deltaY, arrowLength, arrowWidth)
 688
 689             points = [[tip_x, tip_y],
 690                     [side1_x, side1_y],
 691                     [side2_x, side2_y],
 692                     [tip_x, tip_y]]
 693
 694             dc.SetPen(self._pen)
 695             dc.SetBrush(self._brush)
 696             dc.DrawPolygon(points)
 697         elif at in [ARROW_HOLLOW_CIRCLE, ARROW_FILLED_CIRCLE]:
 698             # Find point on line of centre of circle, which is a radius away
 699             # from the end position
 700             diameter = arrow.GetSize()
 701             x, y = GetPointOnLine(startPositionX + deltaX, startPositionY + deltaY,
 702                                positionOnLineX + deltaX, positionOnLineY + deltaY,
 703                                diameter / 2)
 704             x1 = x-diameter / 2
 705             y1 = y-diameter / 2
 706             dc.SetPen(self._pen)
 707             if arrow._GetType() == ARROW_HOLLOW_CIRCLE:
 708                 dc.SetBrush(self.GetBackgroundBrush())
 709             else:
 710                 dc.SetBrush(self._brush)
 711
 712             dc.DrawEllipse(x1, y1, diameter, diameter)
 713         elif at == ARROW_SINGLE_OBLIQUE:
 714             pass
 715         elif at == ARROW_METAFILE:
 716             if arrow.GetMetaFile():
 717                 # Find point on line of centre of object, which is a half-width away
 718                 # from the end position
 719                 #
 720                 #                 width
 721                 #  <-- start pos  <-----><-- positionOnLineX
 722                 #                 _____
 723                 #  --------------|  x  | <-- e.g. rectangular arrowhead
 724                 #                 -----
 725                 #
 726                 x, y = GetPointOnLine(startPositionX, startPositionY,
 727                                    positionOnLineX, positionOnLineY,
 728                                    arrow.GetMetaFile()._width / 2)
 729                 # Calculate theta for rotating the metafile.
 730                 #
 731                 # |
 732                 # |     o(x2, y2)   'o' represents the arrowhead.
 733                 # |    /
 734                 # |   /
 735                 # |  /theta
 736                 # | /(x1, y1)
 737                 # |______________________
 738                 #
 739                 theta = 0.0
 740                 x1 = startPositionX
 741                 y1 = startPositionY
 742                 x2 = positionOnLineX
 743                 y2 = positionOnLineY
 744
 745                 if x1 == x2 and y1 == y2:
 746                     theta = 0.0
 747                 elif x1 == x2 and y1>y2:
 748                     theta = 3.0 * pi / 2
 749                 elif x1 == x2 and y2>y1:
 750                     theta = pi / 2
 751                 elif x2>x1 and y2 >= y1:
 752                     theta = atan((y2-y1) / (x2-x1))
 753                 elif x2<x1:
 754                     theta = pi + atan((y2-y1) / (x2-x1))
 755                 elif x2>x1 and y2<y1:
 756                     theta = 2 * pi + atan((y2-y1) / (x2-x1))
 757                 else:
 758                     raise "Unknown arrowhead rotation case"
 759
 760                 # Rotate about the centre of the object, then place
 761                 # the object on the line.
 762                 if arrow.GetMetaFile().GetRotateable():
 763                     arrow.GetMetaFile().Rotate(0.0, 0.0, theta)
 764
 765                 if self._erasing:
 766                     # If erasing, just draw a rectangle
 767                     minX, minY, maxX, maxY = arrow.GetMetaFile().GetBounds()
 768                     # Make erasing rectangle slightly bigger or you get droppings
 769                     extraPixels = 4
 770                     dc.DrawRectangle(deltaX + x + minX-extraPixels / 2, deltaY + y + minY-extraPixels / 2, maxX-minX + extraPixels, maxY-minY + extraPixels)
 771                 else:
 772                     arrow.GetMetaFile().Draw(dc, x + deltaX, y + deltaY)
 773
 774     def OnErase(self, dc):
 775         old_pen = self._pen
 776         old_brush = self._brush
 777
 778         bg_pen = self.GetBackgroundPen()
 779         bg_brush = self.GetBackgroundBrush()
 780         self.SetPen(bg_pen)
 781         self.SetBrush(bg_brush)
 782
 783         bound_x, bound_y = self.GetBoundingBoxMax()
 784         if self._font:
 785             dc.SetFont(self._font)
 786
 787         # Undraw text regions
 788         for i in range(3):
 789             if self._regions[i]:
 790                 x, y = self.GetLabelPosition(i)
 791                 self.EraseRegion(dc, self._regions[i], x, y)
 792
 793         # Undraw line
 794         dc.SetPen(self.GetBackgroundPen())
 795         dc.SetBrush(self.GetBackgroundBrush())
 796
 797         # Drawing over the line only seems to work if the line has a thickness
 798         # of 1.
 799         if old_pen and old_pen.GetWidth()>1:
 800             dc.DrawRectangle(self._xpos-bound_x / 2-2, self._ypos-bound_y / 2-2,
 801                              bound_x + 4, bound_y + 4)
 802         else:
 803             self._erasing = True
 804             self.GetEventHandler().OnDraw(dc)
 805             self.GetEventHandler().OnEraseControlPoints(dc)
 806             self._erasing = False
 807
 808         if old_pen:
 809             self.SetPen(old_pen)
 810         if old_brush:
 811             self.SetBrush(old_brush)
 812
 813     def GetBoundingBoxMin(self):
 814         x1, y1 = 10000, 10000
 815         x2, y2=-10000,-10000
 816
 817         for point in self._lineControlPoints:
 818             if point[0]<x1:
 819                 x1 = point[0]
 820             if point[1]<y1:
 821                 y1 = point[1]
 822             if point[0]>x2:
 823                 x2 = point[0]
 824             if point[1]>y2:
 825                 y2 = point[1]
 826
 827         return x2-x1, y2-y1
 828
 829     # For a node image of interest, finds the position of this arc
 830     # amongst all the arcs which are attached to THIS SIDE of the node image,
 831     # and the number of same.
 832     def FindNth(self, image, incoming):
 833         """Find the position of the line on the given object.
 834
 835         Specify whether incoming or outgoing lines are being considered
 836         with incoming.
 837         """
 838         n=-1
 839         num = 0
 840
 841         if image == self._to:
 842             this_attachment = self._attachmentTo
 843         else:
 844             this_attachment = self._attachmentFrom
 845
 846         # Find number of lines going into / out of this particular attachment point
 847         for line in image.GetLines():
 848             if line._from == image:
 849                 # This is the nth line attached to 'image'
 850                 if line == self and not incoming:
 851                     n = num
 852
 853                 # Increment num count if this is the same side (attachment number)
 854                 if line._attachmentFrom == this_attachment:
 855                     num += 1
 856
 857             if line._to == image:
 858                 # This is the nth line attached to 'image'
 859                 if line == self and incoming:
 860                     n = num
 861
 862                 # Increment num count if this is the same side (attachment number)
 863                 if line._attachmentTo == this_attachment:
 864                     num += 1
 865
 866         return n, num
 867
 868     def OnDrawOutline(self, dc, x, y, w, h):
 869         old_pen = self._pen
 870         old_brush = self._brush
 871
 872         dottedPen = wx.Pen(wx.Colour(0, 0, 0), 1, wx.DOT)
 873         self.SetPen(dottedPen)
 874         self.SetBrush(wx.TRANSPARENT_BRUSH)
 875
 876         self.GetEventHandler().OnDraw(dc)
 877
 878         if old_pen:
 879             self.SetPen(old_pen)
 880         else:
 881             self.SetPen(None)
 882         if old_brush:
 883             self.SetBrush(old_brush)
 884         else:
 885             self.SetBrush(None)
 886
 887     def OnMovePre(self, dc, x, y, old_x, old_y, display = True):
 888         x_offset = x-old_x
 889         y_offset = y-old_y
 890
 891         if self._lineControlPoints and not (x_offset == 0 and y_offset == 0):
 892             for point in self._lineControlPoints:
 893                 point[0] += x_offset
 894                 point[1] += y_offset
 895
 896         # Move temporary label rectangles if necessary
 897         for i in range(3):
 898             if self._labelObjects[i]:
 899                 self._labelObjects[i].Erase(dc)
 900                 xp, yp = self.GetLabelPosition(i)
 901                 if i<len(self._regions):
 902                     xr, yr = self._regions[i].GetPosition()
 903                 else:
 904                     xr, yr = 0, 0
 905                 self._labelObjects[i].Move(dc, xp + xr, yp + yr)
 906         return True
 907
 908     def OnMoveLink(self, dc, moveControlPoints = True):
 909         """Called when a connected object has moved, to move the link to
 910         correct position
 911         """
 912         if not self._from or not self._to:
 913             return
 914
 915         if len(self._lineControlPoints)>2:
 916             self.Initialise()
 917
 918         # Do each end - nothing in the middle. User has to move other points
 919         # manually if necessary
 920         end_x, end_y, other_end_x, other_end_y = self.FindLineEndPoints()
 921
 922         first = self._lineControlPoints[0]
 923         last = self._lineControlPoints[-1]
 924
 925         oldX, oldY = self._xpos, self._ypos
 926
 927         self.SetEnds(end_x, end_y, other_end_x, other_end_y)
 928
 929         # Do a second time, because one may depend on the other
 930         end_x, end_y, other_end_x, other_end_y = self.FindLineEndPoints()
 931         self.SetEnds(end_x, end_y, other_end_x, other_end_y)
 932
 933         # Try to move control points with the arc
 934         x_offset = self._xpos-oldX
 935         y_offset = self._ypos-oldY
 936
 937         # Only move control points if it's a self link. And only works
 938         # if attachment mode is ON
 939         if self._from == self._to and self._from.GetAttachmentMode() != ATTACHMENT_MODE_NONE and moveControlPoints and self._lineControlPoints and not (x_offset == 0 and y_offset == 0):
 940             for point in self._lineControlPoints[1:-1]:
 941                 point.x += x_offset
 942                 point.y += y_offset
 943
 944         self.Move(dc, self._xpos, self._ypos)
 945
 946     def FindLineEndPoints(self):
 947         """Finds the x, y points at the two ends of the line.
 948
 949         This function can be used by e.g. line-routing routines to
 950         get the actual points on the two node images where the lines will be
 951         drawn to / from.
 952         """
 953         if not self._from or not self._to:
 954             return
 955
 956         # Do each end - nothing in the middle. User has to move other points
 957         # manually if necessary.
 958         second_point = self._lineControlPoints[1]
 959         second_last_point = self._lineControlPoints[-2]
 960
 961         if len(self._lineControlPoints)>2:
 962             if self._from.GetAttachmentMode() != ATTACHMENT_MODE_NONE:
 963                 nth, no_arcs = self.FindNth(self._from, False) # Not incoming
 964                 end_x, end_y = self._from.GetAttachmentPosition(self._attachmentFrom, nth, no_arcs, self)
 965             else:
 966                 end_x, end_y = self._from.GetPerimeterPoint(self._from.GetX(), self._from.GetY(), second_point[0], second_point[1])
 967
 968             if self._to.GetAttachmentMode() != ATTACHMENT_MODE_NONE:
 969                 nth, no_arch = self.FindNth(self._to, True) # Incoming
 970                 other_end_x, other_end_y = self._to.GetAttachmentPosition(self._attachmentTo, nth, no_arch, self)
 971             else:
 972                 other_end_x, other_end_y = self._to.GetPerimeterPoint(self._to.GetX(), self._to.GetY(), second_last_point[0], second_last_point[1])
 973         else:
 974             fromX = self._from.GetX()
 975             fromY = self._from.GetY()
 976             toX = self._to.GetX()
 977             toY = self._to.GetY()
 978
 979             if self._from.GetAttachmentMode() != ATTACHMENT_MODE_NONE:
 980                 nth, no_arcs = self.FindNth(self._from, False)
 981                 end_x, end_y = self._from.GetAttachmentPosition(self._attachmentFrom, nth, no_arcs, self)
 982                 fromX = end_x
 983                 fromY = end_y
 984
 985             if self._to.GetAttachmentMode() != ATTACHMENT_MODE_NONE:
 986                 nth, no_arcs = self.FindNth(self._to, True)
 987                 other_end_x, other_end_y = self._to.GetAttachmentPosition(self._attachmentTo, nth, no_arcs, self)
 988                 toX = other_end_x
 989                 toY = other_end_y
 990
 991             if self._from.GetAttachmentMode() == ATTACHMENT_MODE_NONE:
 992                 end_x, end_y = self._from.GetPerimeterPoint(self._from.GetX(), self._from.GetY(), toX, toY)
 993
 994             if self._to.GetAttachmentMode() == ATTACHMENT_MODE_NONE:
 995                 other_end_x, other_end_y = self._to.GetPerimeterPoint(self._to.GetX(), self._to.GetY(), fromX, fromY)
 996
 997             #print type(self._from), type(self._to), end_x, end_y, other_end_x, other_end_y
 998             return end_x, end_y, other_end_x, other_end_y
 999
1000     def OnDraw(self, dc):
1001         if not self._lineControlPoints:
1002             return
1003
1004         if self._pen:
1005             dc.SetPen(self._pen)
1006         if self._brush:
1007             dc.SetBrush(self._brush)
1008
1009         points = []
1010         for point in self._lineControlPoints:
1011             points.append(wx.Point(point.x, point.y))
1012
1013         #print points
1014         if self._isSpline:
1015             dc.DrawSpline(points)
1016         else:
1017             dc.DrawLines(points)
1018
1019         if sys.platform[:3]=="win":
1020             # For some reason, last point isn't drawn under Windows
1021             pt = points[-1]
1022             dc.DrawPoint(pt.x, pt.y)
1023
1024         # Problem with pen - if not a solid pen, does strange things
1025         # to the arrowhead. So make (get) a new pen that's solid.
1026         if self._pen and self._pen.GetStyle() != wx.SOLID:
1027             solid_pen = wx.ThePenList().FindOrCreatePen(self._pen.GetColour(), 1, wx.SOLID)
1028             if solid_pen:
1029                 dc.SetPen(solid_pen)
1030
1031         self.DrawArrows(dc)
1032
1033     def OnDrawControlPoints(self, dc):
1034         if not self._drawHandles:
1035             return
1036
1037         # Draw temporary label rectangles if necessary
1038         for i in range(3):
1039             if self._labelObjects[i]:
1040                 self._labelObjects[i].Draw(dc)
1041
1042         Shape.OnDrawControlPoints(self, dc)
1043
1044     def OnEraseControlPoints(self, dc):
1045         # Erase temporary label rectangles if necessary
1046
1047         for i in range(3):
1048             if self._labelObjects[i]:
1049                 self._labelObjects[i].Erase(dc)
1050
1051         Shape.OnEraseControlPoints(self, dc)
1052
1053     def OnDragLeft(self, draw, x, y, keys = 0, attachment = 0):
1054         pass
1055
1056     def OnBeginDragLeft(self, x, y, keys = 0, attachment = 0):
1057         pass
1058
1059     def OnEndDragLeft(self, x, y, keys = 0, attachment = 0):
1060         pass
1061
1062     def OnDrawContents(self, dc):
1063         if self.GetDisableLabel():
1064             return
1065
1066         for i in range(3):
1067             if self._regions[i]:
1068                 x, y = self.GetLabelPosition(i)
1069                 self.DrawRegion(dc, self._regions[i], x, y)
1070
1071     def SetTo(self, object):
1072         """Set the 'to' object for the line."""
1073         self._to = object
1074
1075     def SetFrom(self, object):
1076         """Set the 'from' object for the line."""
1077         self._from = object
1078
1079     def MakeControlPoints(self):
1080         """Make handle control points."""
1081         if self._canvas and self._lineControlPoints:
1082             first = self._lineControlPoints[0]
1083             last = self._lineControlPoints[-1]
1084
1085             control = LineControlPoint(self._canvas, self, CONTROL_POINT_SIZE, first[0], first[1], CONTROL_POINT_ENDPOINT_FROM)
1086             control._point = first
1087             self._canvas.AddShape(control)
1088             self._controlPoints.Append(control)
1089
1090             for point in self._lineControlPoints[1:-1]:
1091                 control = LineControlPoint(self._canvas, self, CONTROL_POINT_SIZE, point[0], point[1], CONTROL_POINT_LINE)
1092                 control._point = point
1093                 self._canvas.AddShape(control)
1094                 self._controlPoints.Append(control)
1095
1096             control = LineControlPoint(self._canvas, self, CONTROL_POINT_SIZE, last[0], last[1], CONTROL_POINT_ENDPOINT_TO)
1097             control._point = last
1098             self._canvas.AddShape(control)
1099             self._controlPoints.Append(control)
1100
1101     def ResetControlPoints(self):
1102         if self._canvas and self._lineControlPoints:
1103             for i in range(min(len(self._controlPoints), len(self._lineControlPoints))):
1104                 point = self._lineControlPoints[i]
1105                 control = self._controlPoints[i]
1106                 control.SetX(point[0])
1107                 control.SetY(point[1])
1108
1109     # Override select, to create / delete temporary label-moving objects
1110     def Select(self, select, dc = None):
1111         Shape.Select(self, select, dc)
1112         if select:
1113             for i in range(3):
1114                 if self._regions[i]:
1115                     region = self._regions[i]
1116                     if region._formattedText:
1117                         w, h = region.GetSize()
1118                         x, y = region.GetPosition()
1119                         xx, yy = self.GetLabelPosition(i)
1120
1121                         if self._labelObjects[i]:
1122                             self._labelObjects[i].Select(False)
1123                             self._labelObjects[i].RemoveFromCanvas(self._canvas)
1124
1125                         self._labelObjects[i] = self.OnCreateLabelShape(self, region, w, h)
1126                         self._labelObjects[i].AddToCanvas(self._canvas)
1127                         self._labelObjects[i].Show(True)
1128                         if dc:
1129                             self._labelObjects[i].Move(dc, x + xx, y + yy)
1130                         self._labelObjects[i].Select(True, dc)
1131         else:
1132             for i in range(3):
1133                 if self._labelObjects[i]:
1134                     self._labelObjects[i].Select(False, dc)
1135                     self._labelObjects[i].Erase(dc)
1136                     self._labelObjects[i].RemoveFromCanvas(self._canvas)
1137                     self._labelObjects[i] = None
1138
1139     # Control points ('handles') redirect control to the actual shape, to
1140     # make it easier to override sizing behaviour.
1141     def OnSizingDragLeft(self, pt, draw, x, y, keys = 0, attachment = 0):
1142         dc = wx.ClientDC(self.GetCanvas())
1143         self.GetCanvas().PrepareDC(dc)
1144
1145         dc.SetLogicalFunction(OGLRBLF)
1146
1147         dottedPen = wx.Pen(wx.Colour(0, 0, 0), 1, wx.DOT)
1148         dc.SetPen(dottedPen)
1149         dc.SetBrush(wx.TRANSPARENT_BRUSH)
1150
1151         if pt._type == CONTROL_POINT_LINE:
1152             x, y = self._canvas.Snap()
1153
1154             pt.SetX(x)
1155             pt.SetY(y)
1156             pt._point[0] = x
1157             pt._point[1] = y
1158
1159             old_pen = self.GetPen()
1160             old_brush = self.GetBrush()
1161
1162             self.SetPen(dottedPen)
1163             self.SetBrush(wx.TRANSPARENT_BRUSH)
1164
1165             self.GetEventHandler().OnMoveLink(dc, False)
1166
1167             self.SetPen(old_pen)
1168             self.SetBrush(old_brush)
1169
1170     def OnSizingBeginDragLeft(self, pt, x, y, keys = 0, attachment = 0):
1171         dc = wx.ClientDC(self.GetCanvas())
1172         self.GetCanvas().PrepareDC(dc)
1173
1174         if pt._type == CONTROL_POINT_LINE:
1175             pt._originalPos = pt._point
1176             x, y = self._canvas.Snap()
1177
1178             self.Erase(dc)
1179
1180             # Redraw start and end objects because we've left holes
1181             # when erasing the line
1182             self.GetFrom().OnDraw(dc)
1183             self.GetFrom().OnDrawContents(dc)
1184             self.GetTo().OnDraw(dc)
1185             self.GetTo().OnDrawContents(dc)
1186
1187             self.SetDisableLabel(True)
1188             dc.SetLogicalFunction(OGLRBLF)
1189
1190             pt._xpos = x
1191             pt._ypos = y
1192             pt._point[0] = x
1193             pt._point[1] = y
1194
1195             old_pen = self.GetPen()
1196             old_brush = self.GetBrush()
1197
1198             dottedPen = wx.Pen(wx.Colour(0, 0, 0), 1, wx.DOT)
1199             self.SetPen(dottedPen)
1200             self.SetBrush(wx.TRANSPARENT_BRUSH)
1201
1202             self.GetEventHandler().OnMoveLink(dc, False)
1203
1204             self.SetPen(old_pen)
1205             self.SetBrush(old_brush)
1206
1207         if pt._type == CONTROL_POINT_ENDPOINT_FROM or pt._type == CONTROL_POINT_ENDPOINT_TO:
1208             self._canvas.SetCursor(wx.Cursor(wx.CURSOR_BULLSEYE))
1209             pt._oldCursor = wx.STANDARD_CURSOR
1210
1211     def OnSizingEndDragLeft(self, pt, x, y, keys = 0, attachment = 0):
1212         dc = wx.ClientDC(self.GetCanvas())
1213         self.GetCanvas().PrepareDC(dc)
1214
1215         self.SetDisableLabel(False)
1216
1217         if pt._type == CONTROL_POINT_LINE:
1218             x, y = self._canvas.Snap()
1219
1220             rpt = wx.RealPoint(x, y)
1221
1222             # Move the control point back to where it was;
1223             # MoveControlPoint will move it to the new position
1224             # if it decides it wants. We only moved the position
1225             # during user feedback so we could redraw the line
1226             # as it changed shape.
1227             pt._xpos = pt._originalPos[0]
1228             pt._ypos = pt._originalPos[1]
1229             pt._point[0] = pt._originalPos[0]
1230             pt._point[1] = pt._originalPos[1]
1231
1232             self.OnMoveMiddleControlPoint(dc, pt, rpt)
1233
1234         if pt._type == CONTROL_POINT_ENDPOINT_FROM:
1235             if pt._oldCursor:
1236                 self._canvas.SetCursor(pt._oldCursor)
1237
1238                 if self.GetFrom():
1239                     self.GetFrom().MoveLineToNewAttachment(dc, self, x, y)
1240
1241         if pt._type == CONTROL_POINT_ENDPOINT_TO:
1242             if pt._oldCursor:
1243                 self._canvas.SetCursor(pt._oldCursor)
1244
1245                 if self.GetTo():
1246                     self.GetTo().MoveLineToNewAttachment(dc, self, x, y)
1247
1248     # This is called only when a non-end control point is moved
1249     def OnMoveMiddleControlPoint(self, dc, lpt, pt):
1250         lpt._xpos = pt[0]
1251         lpt._ypos = pt[1]
1252
1253         lpt._point[0] = pt[0]
1254         lpt._point[1] = pt[1]
1255
1256         self.GetEventHandler().OnMoveLink(dc)
1257
1258         return True
1259
1260     def AddArrow(self, type, end = ARROW_POSITION_END, size = 10.0, xOffset = 0.0, name="",mf = None, arrowId=-1):
1261         """Add an arrow (or annotation) to the line.
1262
1263         type may currently be one of:
1264
1265         ARROW_HOLLOW_CIRCLE
1266           Hollow circle.
1267         ARROW_FILLED_CIRCLE
1268           Filled circle.
1269         ARROW_ARROW
1270           Conventional arrowhead.
1271         ARROW_SINGLE_OBLIQUE
1272           Single oblique stroke.
1273         ARROW_DOUBLE_OBLIQUE
1274           Double oblique stroke.
1275         ARROW_DOUBLE_METAFILE
1276           Custom arrowhead.
1277
1278         end may currently be one of:
1279
1280         ARROW_POSITION_END
1281           Arrow appears at the end.
1282         ARROW_POSITION_START
1283           Arrow appears at the start.
1284
1285         arrowSize specifies the length of the arrow.
1286
1287         xOffset specifies the offset from the end of the line.
1288
1289         name specifies a name for the arrow.
1290
1291         mf can be a wxPseduoMetaFile, perhaps loaded from a simple Windows
1292         metafile.
1293
1294         arrowId is the id for the arrow.
1295         """
1296         arrow = ArrowHead(type, end, size, xOffset, name, mf, arrowId)
1297         self._arcArrows.append(arrow)
1298         return arrow
1299
1300     # Add arrowhead at a particular position in the arrowhead list
1301     def AddArrowOrdered(self, arrow, referenceList, end):
1302         """Add an arrowhead in the position indicated by the reference list
1303         of arrowheads, which contains all legal arrowheads for this line, in
1304         the correct order. E.g.
1305
1306         Reference list:      a b c d e
1307         Current line list:   a d
1308
1309         Add c, then line list is: a c d.
1310
1311         If no legal arrowhead position, return FALSE. Assume reference list
1312         is for one end only, since it potentially defines the ordering for
1313         any one of the 3 positions. So we don't check the reference list for
1314         arrowhead position.
1315         """
1316         if not referenceList:
1317             return False
1318
1319         targetName = arrow.GetName()
1320
1321         # First check whether we need to insert in front of list,
1322         # because this arrowhead is the first in the reference
1323         # list and should therefore be first in the current list.
1324         refArrow = referenceList[0]
1325         if refArrow.GetName() == targetName:
1326             self._arcArrows.insert(0, arrow)
1327             return True
1328
1329         i1 = i2 = 0
1330         while i1<len(referenceList) and i2<len(self._arcArrows):
1331             refArrow = referenceList[i1]
1332             currArrow = self._arcArrows[i2]
1333
1334             # Matching: advance current arrow pointer
1335             if currArrow.GetArrowEnd() == end and currArrow.GetName() == refArrow.GetName():
1336                 i2 += 1
1337
1338             # Check if we're at the correct position in the
1339             # reference list
1340             if targetName == refArrow.GetName():
1341                 if i2<len(self._arcArrows):
1342                     self._arcArrows.insert(i2, arrow)
1343                 else:
1344                     self._arcArrows.append(arrow)
1345                 return True
1346             i1 += 1
1347
1348         self._arcArrows.append(arrow)
1349         return True
1350
1351     def ClearArrowsAtPosition(self, end):
1352         """Delete the arrows at the specified position, or at any position
1353         if position is -1.
1354         """
1355         if end==-1:
1356             self._arcArrows = []
1357             return
1358
1359         for arrow in self._arcArrows:
1360             if arrow.GetArrowEnd() == end:
1361                 self._arcArrows.remove(arrow)
1362
1363     def ClearArrow(self, name):
1364         """Delete the arrow with the given name."""
1365         for arrow in self._arcArrows:
1366             if arrow.GetName() == name:
1367                 self._arcArrows.remove(arrow)
1368                 return True
1369         return False
1370
1371     def FindArrowHead(self, position, name):
1372         """Find arrowhead by position and name.
1373
1374         if position is -1, matches any position.
1375         """
1376         for arrow in self._arcArrows:
1377             if (position==-1 or position == arrow.GetArrowEnd()) and arrow.GetName() == name:
1378                 return arow
1379
1380         return None
1381
1382     def FindArrowHeadId(self, arrowId):
1383         """Find arrowhead by id."""
1384         for arrow in self._arcArrows:
1385             if arrowId == arrow.GetId():
1386                 return arrow
1387
1388         return None
1389
1390     def DeleteArrowHead(self, position, name):
1391         """Delete arrowhead by position and name.
1392
1393         if position is -1, matches any position.
1394         """
1395         for arrow in self._arcArrows:
1396             if (position==-1 or position == arrow.GetArrowEnd()) and arrow.GetName() == name:
1397                 self._arcArrows.remove(arrow)
1398                 return True
1399         return False
1400
1401     def DeleteArrowHeadId(self, id):
1402         """Delete arrowhead by id."""
1403         for arrow in self._arcArrows:
1404             if arrowId == arrow.GetId():
1405                 self._arcArrows.remove(arrow)
1406                 return True
1407         return False
1408
1409     # Calculate the minimum width a line
1410     # occupies, for the purposes of drawing lines in tools.
1411     def FindMinimumWidth(self):
1412         """Find the horizontal width for drawing a line with arrows in
1413         minimum space. Assume arrows at end only.
1414         """
1415         minWidth = 0.0
1416         for arrowHead in self._arcArrows:
1417             minWidth += arrowHead.GetSize()
1418             if arrowHead != self._arcArrows[-1]:
1419                 minWidth += arrowHead + GetSpacing
1420
1421         # We have ABSOLUTE minimum now. So
1422         # scale it to give it reasonable aesthetics
1423         # when drawing with line.
1424         if minWidth>0:
1425             minWidth = minWidth * 1.4
1426         else:
1427             minWidth = 20.0
1428
1429         self.SetEnds(0.0, 0.0, minWidth, 0.0)
1430         self.Initialise()
1431
1432         return minWidth
1433
1434     def FindLinePosition(self, x, y):
1435         """Find which position we're talking about at this x, y.
1436
1437         Returns ARROW_POSITION_START, ARROW_POSITION_MIDDLE, ARROW_POSITION_END.
1438         """
1439         startX, startY, endX, endY = self.GetEnds()
1440
1441         # Find distances from centre, start and end. The smallest wins
1442         centreDistance = sqrt((x-self._xpos) * (x-self._xpos) + (y-self._ypos) * (y-self._ypos))
1443         startDistance = sqrt((x-startX) * (x-startX) + (y-startY) * (y-startY))
1444         endDistance = sqrt((x-endX) * (x-endX) + (y-endY) * (y-endY))
1445
1446         if centreDistance<startDistance and centreDistance<endDistance:
1447             return ARROW_POSITION_MIDDLE
1448         elif startDistance<endDistance:
1449             return ARROW_POSITION_START
1450         else:
1451             return ARROW_POSITION_END
1452
1453     def SetAlignmentOrientation(self, isEnd, isHoriz):
1454         if isEnd:
1455             if isHoriz and self._alignmentEnd & LINE_ALIGNMENT_HORIZ != LINE_ALIGNMENT_HORIZ:
1456                 self._alignmentEnd != LINE_ALIGNMENT_HORIZ
1457             elif not isHoriz and self._alignmentEnd & LINE_ALIGNMENT_HORIZ == LINE_ALIGNMENT_HORIZ:
1458                 self._alignmentEnd -= LINE_ALIGNMENT_HORIZ
1459         else:
1460             if isHoriz and self._alignmentStart & LINE_ALIGNMENT_HORIZ != LINE_ALIGNMENT_HORIZ:
1461                 self._alignmentStart != LINE_ALIGNMENT_HORIZ
1462             elif not isHoriz and self._alignmentStart & LINE_ALIGNMENT_HORIZ == LINE_ALIGNMENT_HORIZ:
1463                 self._alignmentStart -= LINE_ALIGNMENT_HORIZ
1464
1465     def SetAlignmentType(self, isEnd, alignType):
1466         if isEnd:
1467             if alignType == LINE_ALIGNMENT_TO_NEXT_HANDLE:
1468                 if self._alignmentEnd & LINE_ALIGNMENT_TO_NEXT_HANDLE != LINE_ALIGNMENT_TO_NEXT_HANDLE:
1469                     self._alignmentEnd |= LINE_ALIGNMENT_TO_NEXT_HANDLE
1470             elif self._alignmentEnd & LINE_ALIGNMENT_TO_NEXT_HANDLE == LINE_ALIGNMENT_TO_NEXT_HANDLE:
1471                 self._alignmentEnd -= LINE_ALIGNMENT_TO_NEXT_HANDLE
1472         else:
1473             if alignType == LINE_ALIGNMENT_TO_NEXT_HANDLE:
1474                 if self._alignmentStart & LINE_ALIGNMENT_TO_NEXT_HANDLE != LINE_ALIGNMENT_TO_NEXT_HANDLE:
1475                     self._alignmentStart |= LINE_ALIGNMENT_TO_NEXT_HANDLE
1476             elif self._alignmentStart & LINE_ALIGNMENT_TO_NEXT_HANDLE == LINE_ALIGNMENT_TO_NEXT_HANDLE:
1477                 self._alignmentStart -= LINE_ALIGNMENT_TO_NEXT_HANDLE
1478
1479     def GetAlignmentOrientation(self, isEnd):
1480         if isEnd:
1481             return self._alignmentEnd & LINE_ALIGNMENT_HORIZ == LINE_ALIGNMENT_HORIZ
1482         else:
1483             return self._alignmentStart & LINE_ALIGNMENT_HORIZ == LINE_ALIGNMENT_HORIZ
1484
1485     def GetAlignmentType(self, isEnd):
1486         if isEnd:
1487             return self._alignmentEnd & LINE_ALIGNMENT_TO_NEXT_HANDLE
1488         else:
1489             return self._alignmentStart & LINE_ALIGNMENT_TO_NEXT_HANDLE
1490
1491     def GetNextControlPoint(self, shape):
1492         """Find the next control point in the line after the start / end point,
1493         depending on whether the shape is at the start or end.
1494         """
1495         n = len(self._lineControlPoints)
1496         if self._to == shape:
1497             # Must be END of line, so we want (n - 1)th control point.
1498             # But indexing ends at n-1, so subtract 2.
1499             nn = n-2
1500         else:
1501             nn = 1
1502         if nn<len(self._lineControlPoints):
1503             return self._lineControlPoints[nn]
1504         return None
1505
1506     def OnCreateLabelShape(self, parent, region, w, h):
1507         return LabelShape(parent, region, w, h)
1508
1509
1510     def OnLabelMovePre(self, dc, labelShape, x, y, old_x, old_y, display):
1511         labelShape._shapeRegion.SetSize(labelShape.GetWidth(), labelShape.GetHeight())
1512
1513         # Find position in line's region list
1514         i = 0
1515         for region in self.GetRegions():
1516             if labelShape._shapeRegion == region:
1517                 self.GetRegions().remove(region)
1518             else:
1519                 i += 1
1520
1521         xx, yy = self.GetLabelPosition(i)
1522         # Set the region's offset, relative to the default position for
1523         # each region.
1524         labelShape._shapeRegion.SetPosition(x-xx, y-yy)
1525         labelShape.SetX(x)
1526         labelShape.SetY(y)
1527
1528         # Need to reformat to fit region
1529         if labelShape._shapeRegion.GetText():
1530             s = labelShape._shapeRegion.GetText()
1531             labelShape.FormatText(dc, s, i)
1532             self.DrawRegion(dc, labelShape._shapeRegion, xx, yy)
1533         return True
1534