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