Ignore:
Timestamp:
03/14/13 12:45:51 (13 months ago)
Author:
Ales Erjavec <ales.erjavec@…>
Branch:
default
Message:

Refactored out the arrow path constructor methods into module functions.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • Orange/OrangeCanvas/canvas/items/annotationitem.py

    r11273 r11400  
    348348    def __updateArrowPath(self): 
    349349        if self.__arrowStyle == ArrowItem.Plain: 
    350             path = self.__arrowPathPlain() 
     350            path = arrow_path_plain(self.__line, self.__lineWidth) 
    351351        else: 
    352             path = self.__arrowPathConcave() 
     352            path = arrow_path_concave(self.__line, self.__lineWidth) 
    353353        self.setPath(path) 
    354354 
    355     def __arrowPathPlain(self): 
    356         line = self.__line 
    357         width = self.__lineWidth 
    358         path = QPainterPath() 
    359         p1, p2 = line.p1(), line.p2() 
    360  
    361         if p1 == p2: 
    362             return path 
    363  
    364         baseline = QLineF(line) 
    365         # Require some minimum length. 
    366         baseline.setLength(max(line.length() - width * 3, width * 3)) 
    367         path.moveTo(baseline.p1()) 
    368         path.lineTo(baseline.p2()) 
    369  
    370         stroker = QPainterPathStroker() 
    371         stroker.setWidth(width) 
    372         path = stroker.createStroke(path) 
    373  
    374         arrow_head_len = width * 4 
    375         arrow_head_angle = 50 
    376         line_angle = line.angle() - 180 
    377  
    378         angle_1 = line_angle - arrow_head_angle / 2.0 
    379         angle_2 = line_angle + arrow_head_angle / 2.0 
    380  
    381         points = [p2, 
    382                   p2 + QLineF.fromPolar(arrow_head_len, angle_1).p2(), 
    383                   p2 + QLineF.fromPolar(arrow_head_len, angle_2).p2(), 
    384                   p2] 
    385  
    386         poly = QPolygonF(points) 
    387         path_head = QPainterPath() 
    388         path_head.addPolygon(poly) 
    389         path = path.united(path_head) 
     355 
     356def arrow_path_plain(line, width): 
     357    """ 
     358    Return an :class:`QPainterPath` of a plain looking arrow. 
     359    """ 
     360    path = QPainterPath() 
     361    p1, p2 = line.p1(), line.p2() 
     362 
     363    if p1 == p2: 
    390364        return path 
    391365 
    392     def __arrowPathConcave(self): 
    393         line = self.__line 
    394         width = self.__lineWidth 
    395         path = QPainterPath() 
    396         p1, p2 = line.p1(), line.p2() 
    397  
    398         if p1 == p2: 
    399             return path 
    400  
    401         baseline = QLineF(line) 
    402         # Require some minimum length. 
    403         baseline.setLength(max(line.length() - width * 3, width * 3)) 
    404  
    405         start, end = baseline.p1(), baseline.p2() 
    406         mid = (start + end) / 2.0 
    407         normal = QLineF.fromPolar(1.0, baseline.angle() + 90).p2() 
    408  
    409         path.moveTo(start) 
    410         path.lineTo(start + (normal * width / 4.0)) 
    411  
    412         path.quadTo(mid + (normal * width / 4.0), 
    413                     end + (normal * width / 1.5)) 
    414  
    415         path.lineTo(end - (normal * width / 1.5)) 
    416         path.quadTo(mid - (normal * width / 4.0), 
    417                     start - (normal * width / 4.0)) 
    418         path.closeSubpath() 
    419  
    420         arrow_head_len = width * 4 
    421         arrow_head_angle = 50 
    422         line_angle = line.angle() - 180 
    423  
    424         angle_1 = line_angle - arrow_head_angle / 2.0 
    425         angle_2 = line_angle + arrow_head_angle / 2.0 
    426  
    427         points = [p2, 
    428                   p2 + QLineF.fromPolar(arrow_head_len, angle_1).p2(), 
    429                   baseline.p2(), 
    430                   p2 + QLineF.fromPolar(arrow_head_len, angle_2).p2(), 
    431                   p2] 
    432  
    433         poly = QPolygonF(points) 
    434         path_head = QPainterPath() 
    435         path_head.addPolygon(poly) 
    436         path = path.united(path_head) 
     366    baseline = QLineF(line) 
     367    # Require some minimum length. 
     368    baseline.setLength(max(line.length() - width * 3, width * 3)) 
     369    path.moveTo(baseline.p1()) 
     370    path.lineTo(baseline.p2()) 
     371 
     372    stroker = QPainterPathStroker() 
     373    stroker.setWidth(width) 
     374    path = stroker.createStroke(path) 
     375 
     376    arrow_head_len = width * 4 
     377    arrow_head_angle = 50 
     378    line_angle = line.angle() - 180 
     379 
     380    angle_1 = line_angle - arrow_head_angle / 2.0 
     381    angle_2 = line_angle + arrow_head_angle / 2.0 
     382 
     383    points = [p2, 
     384              p2 + QLineF.fromPolar(arrow_head_len, angle_1).p2(), 
     385              p2 + QLineF.fromPolar(arrow_head_len, angle_2).p2(), 
     386              p2] 
     387 
     388    poly = QPolygonF(points) 
     389    path_head = QPainterPath() 
     390    path_head.addPolygon(poly) 
     391    path = path.united(path_head) 
     392    return path 
     393 
     394 
     395def arrow_path_concave(line, width): 
     396    """ 
     397    Return a :class:`QPainterPath` of a pretty looking arrow. 
     398    """ 
     399    path = QPainterPath() 
     400    p1, p2 = line.p1(), line.p2() 
     401 
     402    if p1 == p2: 
    437403        return path 
     404 
     405    baseline = QLineF(line) 
     406    # Require some minimum length. 
     407    baseline.setLength(max(line.length() - width * 3, width * 3)) 
     408 
     409    start, end = baseline.p1(), baseline.p2() 
     410    mid = (start + end) / 2.0 
     411    normal = QLineF.fromPolar(1.0, baseline.angle() + 90).p2() 
     412 
     413    path.moveTo(start) 
     414    path.lineTo(start + (normal * width / 4.0)) 
     415 
     416    path.quadTo(mid + (normal * width / 4.0), 
     417                end + (normal * width / 1.5)) 
     418 
     419    path.lineTo(end - (normal * width / 1.5)) 
     420    path.quadTo(mid - (normal * width / 4.0), 
     421                start - (normal * width / 4.0)) 
     422    path.closeSubpath() 
     423 
     424    arrow_head_len = width * 4 
     425    arrow_head_angle = 50 
     426    line_angle = line.angle() - 180 
     427 
     428    angle_1 = line_angle - arrow_head_angle / 2.0 
     429    angle_2 = line_angle + arrow_head_angle / 2.0 
     430 
     431    points = [p2, 
     432              p2 + QLineF.fromPolar(arrow_head_len, angle_1).p2(), 
     433              baseline.p2(), 
     434              p2 + QLineF.fromPolar(arrow_head_len, angle_2).p2(), 
     435              p2] 
     436 
     437    poly = QPolygonF(points) 
     438    path_head = QPainterPath() 
     439    path_head.addPolygon(poly) 
     440    path = path.united(path_head) 
     441    return path 
    438442 
    439443 
Note: See TracChangeset for help on using the changeset viewer.