Python QPainterPath.moveTo方法代码示例

# 需要导入模块: from PySide.QtGui import QPainterPath [as 别名]
# 或者: from PySide.QtGui.QPainterPath import moveTo [as 别名]
class SelectedMineral:
    def __init__(self, parent, code, persistent = False):
        self.parent = parent
        self.persistent = persistent
        self.isActive = True # maybe to delete
        self.code = code
        self.name = self.parent.qtColorsNames[self.code][0]
        self.color = self.parent.qtColorsNames[self.code][1]
        self.painterPath = QPainterPath()
        self.verts, self.edges = parent.fetchMineral(self.code)
        if not self.verts:
            self.isActive = False
        

    # TODO: try to make it static or abstract in the future
    def project(self, projector, alef=19, bet=30):
        self.points = {}
        projector.setupProjectionMatrix(alef, bet)
        for k, v in self.verts.iteritems():
            self.points[k] = projector.project(v).tolist()
        for edge in self.edges.values():
            p1 = self.points[edge[0]]
            p2 = self.points[edge[1]]
            self.painterPath.moveTo(p1[0], p1[1])
            self.painterPath.lineTo(p2[0], p2[1])

# 需要导入模块: from PySide.QtGui import QPainterPath [as 别名]
# 或者: from PySide.QtGui.QPainterPath import moveTo [as 别名]
    def draw_ref(self, painter, option, ref, repo, x):
        if repo.head_ref and posixpath.basename(ref) == 'HEAD':
            return x

        ref_text, ref_type = git_api.parse_ref(ref)
        if ref_type == git_api.REF_BRANCH:
            ref_color = self.ref_palette[ref_type, ref_text == repo.head_ref]
        else:
            ref_color = self.ref_palette.get(ref_type, self.ref_color_default)

        lane_size = option.rect.height()
        painter.setPen(QPen(Qt.black, self.ref_frame_thickness))
        painter.setBrush(QBrush(ref_color))
        painter.setFont(option.font)

        text_rect = painter.boundingRect(0, 0, 0, 0,
            Qt.AlignLeft | Qt.AlignTop, ref_text)
        text_rect.translate(-text_rect.x(), -text_rect.y())
        text_rect.setWidth(text_rect.width() + self.ref_padding_x)
        text_rect.setHeight(text_rect.height() + self.ref_padding_y)
        text_rect.translate(
            x + text_rect.height() * self.ref_arrow_ratio,
            (lane_size - text_rect.height()) / 2)
        path = QPainterPath()
        path.moveTo(x, lane_size / 2)
        path.lineTo(text_rect.left(), text_rect.top())
        path.lineTo(text_rect.right(), text_rect.top())
        path.lineTo(text_rect.right(), text_rect.bottom())
        path.lineTo(text_rect.left(), text_rect.bottom())
        path.lineTo(x, lane_size / 2)
        painter.drawPath(path)
        painter.drawText(text_rect, Qt.AlignLeft | Qt.AlignVCenter, ref_text)
        return text_rect.right() + self.ref_spacing

# 需要导入模块: from PySide.QtGui import QPainterPath [as 别名]
# 或者: from PySide.QtGui.QPainterPath import moveTo [as 别名]
    def __init__(self, parent, scene, view):
        super(QNodesEditor, self).__init__(parent)

        self.scene = scene
        self.scene.installEventFilter(self)

        gridSize = 25
        gridMap = QPixmap(gridSize,gridSize)
        gridPainter = QPainter(gridMap)
        gridPainter.fillRect(0,0,gridSize,gridSize, QApplication.palette().window().color().darker(103))
        gridPainter.fillRect(1,1,gridSize-2,gridSize-2, QApplication.palette().window())
        gridPainter.end()
        self.scene.setBackgroundBrush( QBrush(gridMap) )

        originSize = 50
        originItem = QGraphicsPathItem()
        path = QPainterPath()
        path.moveTo(0,-originSize)
        path.lineTo(0,originSize)
        path.moveTo(-originSize,0)
        path.lineTo(originSize,0)
        originItem.setPath(path)
        originItem.setPen(QPen(QApplication.palette().window().color().darker(110),2))
        originItem.setZValue(-2)
        self.scene.addItem(originItem)

        self.view = view
        self.view.setDragMode(QGraphicsView.RubberBandDrag)
        self.view.setRenderHint(QPainter.Antialiasing)

        self.connection = None

# 需要导入模块: from PySide.QtGui import QPainterPath [as 别名]
# 或者: from PySide.QtGui.QPainterPath import moveTo [as 别名]
 def set_shape(self, width, height):
     ''' Compute the polygon to fit in width, height '''
     path = QPainterPath()
     path.addRect(0, 0, width, height)
     path.moveTo(7, 0)
     path.lineTo(7, height)
     path.moveTo(width - 7, 0)
     path.lineTo(width - 7, height)
     self.setPath(path)
     super(ProcedureCall, self).set_shape(width, height)

# 需要导入模块: from PySide.QtGui import QPainterPath [as 别名]
# 或者: from PySide.QtGui.QPainterPath import moveTo [as 别名]
 def _setupPainterPath(self):
   painter_path = QPainterPath()
   painter_path.moveTo(0, 15) #left
   painter_path.lineTo(0, 0) #up
   painter_path.lineTo(self.width() - 1, 0) # right
   painter_path.lineTo(self.width() - 1, 15) # down
   painter_path.arcTo(QRect(self.width() - 6, 15, 5, 4), 0, -90) # control point1, cp2, destPoint
   painter_path.lineTo(5, 19) # left
   painter_path.arcTo(QRect(1, 15, 5, 4), 270, -90) #arc left up
   painter_path.closeSubpath()
   self._painter_path = painter_path

# 需要导入模块: from PySide.QtGui import QPainterPath [as 别名]
# 或者: from PySide.QtGui.QPainterPath import moveTo [as 别名]
    def updatePath(self):
        path = QPainterPath()
        path.moveTo(self.pos1)

        dx = self.pos2.x() - self.pos1.x()
        dy = self.pos2.y() - self.pos1.y()

        ctr1 = QPointF(self.pos1.x() + dx * 0.25, self.pos1.y() + dy * 0.1)
        ctr2 = QPointF(self.pos1.x() + dx * 0.75, self.pos1.y() + dy * 0.9)

        path.cubicTo(ctr1, ctr2, self.pos2)
        self.setPath(path)

# 需要导入模块: from PySide.QtGui import QPainterPath [as 别名]
# 或者: from PySide.QtGui.QPainterPath import moveTo [as 别名]
    def setLineFromLine(self, li):
        """
        TOWRITE

        :param `li`: TOWRITE
        :type `li`: QPointF
        """
        p = QPainterPath()
        p.moveTo(li.p1())
        p.lineTo(li.p2())
        self.setPath(p)
        self.objLine = li

# 需要导入模块: from PySide.QtGui import QPainterPath [as 别名]
# 或者: from PySide.QtGui.QPainterPath import moveTo [as 别名]
    def subPathList(self):
        """
        TOWRITE

        :rtype: QList<QPainterPath>
        """
        s = self.scale()  # qreal
        trans = QTransform()
        trans.rotate(self.rotation())
        trans.scale(s, s)

        ## QList<QPainterPath> pathList;
        pathList = []
        path = self.objTextPath  # QPainterPath

        element = QPainterPath.Element
        pathMoves = []  # QList<int>
        numMoves = 0  # int

        for i in range(0, path.elementCount()):  # for(int i = 0; i < path.elementCount(); i++)

            element = path.elementAt(i)
            if element.isMoveTo():

                pathMoves.append(i)  # pathMoves << i;
                numMoves += 1  # numMoves++;

        pathMoves.append(path.elementCount())  # pathMoves << path.elementCount();

        for p in range(0, len(pathMoves) - 1):  #  for(int p = 0; p < pathMoves.size()-1 && p < numMoves; p++)
            if not (p < numMoves):
                break

            subPath = QPainterPath()
            for i in range(pathMoves[p], pathMoves[p + 1]):  # for(int i = pathMoves.value(p); i < pathMoves.value(p+1); i++)

                element = path.elementAt(i)
                if element.isMoveTo():
                    subPath.moveTo(element.x, element.y)

                elif element.isLineTo():
                    subPath.lineTo(element.x, element.y)

                elif element.isCurveTo():
                    subPath.cubicTo(path.elementAt(i).x, path.elementAt(i).y,          # control point 1
                                    path.elementAt(i + 1).x, path.elementAt(i + 1).y,  # control point 2
                                    path.elementAt(i + 2).x, path.elementAt(i + 2).y)  # end point

            pathList.append(trans.map(subPath))

        return pathList

# 需要导入模块: from PySide.QtGui import QPainterPath [as 别名]
# 或者: from PySide.QtGui.QPainterPath import moveTo [as 别名]
    def realRender(self, painter, renderPath):  # TODO/PORT: Still needs work.
        """
        TOWRITE

        :param `painter`: TOWRITE
        :type `painter`: `QPainter`_
        :param `renderPath`: TOWRITE
        :type `renderPath`: `QPainterPath`_
        """
        color1 = self.objectColor()  #QColor  # lighter color
        color2 = color1.darker(150)  #QColor  # darker color

        # If we have a dark color, lighten it
        darkness = color1.lightness() #int
        threshold = 32 #int   #TODO: This number may need adjusted or maybe just add it to settings.
        if darkness < threshold:
            color2 = color1
            if not darkness:
                color1 = QColor(threshold, threshold, threshold)  # lighter() does not affect pure black
            else :
                color1 = color2.lighter(100 + threshold)

        count = renderPath.elementCount()  # int
        for i in range(0, count - 1):  # for(int i = 0; i < count-1; ++i);

            elem = renderPath.elementAt(i)      # QPainterPath::Element
            next = renderPath.elementAt(i + 1)  # QPainterPath::Element

            if next.isMoveTo():
                continue

            elemPath = QPainterPath()
            elemPath.moveTo(elem.x, elem.y)
            elemPath.lineTo(next.x, next.y)

            renderPen = QPen(QColor(0, 0, 0, 0))
            renderPen.setWidthF(0)
            painter.setPen(renderPen)
            stroker = QPainterPathStroker()
            stroker.setWidth(0.35)
            stroker.setCapStyle(Qt.RoundCap)
            stroker.setJoinStyle(Qt.RoundJoin)
            realPath = stroker.createStroke(elemPath)  # QPainterPath
            painter.drawPath(realPath)

            grad = QLinearGradient(elemPath.pointAtPercent(0.5), elemPath.pointAtPercent(0.0))
            grad.setColorAt(0, color1)
            grad.setColorAt(1, color2)
            grad.setSpread(QGradient.ReflectSpread)

            painter.fillPath(realPath, QBrush(grad))

# 需要导入模块: from PySide.QtGui import QPainterPath [as 别名]
# 或者: from PySide.QtGui.QPainterPath import moveTo [as 别名]
 def paint(self, painter, styleOption, widget):
   ''' Reimplemented to paint elements in alternating colors '''
   path = self.path()  # alias
   pathEnd = None
   i = 0
   while True:
     try:
       element = path.elementAt(i)
       # print type(element), element.type
       if element.isMoveTo():
         pathEnd = QPointF(element.x, element.y)
         i+=1
       elif element.isCurveTo():
         # Gather curve data, since is spread across elements of type curveElementData
         cp1 = QPointF(element.x, element.y)
         element = path.elementAt(i+1)
         cp2 = QPointF(element.x, element.y)
         element = path.elementAt(i+2)
         newEnd = QPointF(element.x, element.y)
         # create a subpath, since painter has no drawCubic method
         subpath=QPainterPath()
         subpath.moveTo(pathEnd)
         subpath.cubicTo(cp1, cp2, newEnd)
         painter.drawPath(subpath)
         
         pathEnd = newEnd
         i+=3
       else:
         print "unhandled path element", element.type
         i+=1
         """
         TODO: if SegmentStringss contain lines (w/o Direction ControlPoints)
         !!! We don't use QPathElements of type Line
         elif element.isLineTo():
           newEnd = QPointF(element.x, element.y)
           painter.drawLine(pathEnd, newEnd)
           pathEnd = newEnd
           i+=1
         """
       if i >= path.elementCount():
         break
     except Exception as inst:
       print inst
       break
       
     # Alternate colors
     if i%2 == 1:
       painter.setPen(Qt.blue)
     else:
       painter.setPen(Qt.red)

# 需要导入模块: from PySide.QtGui import QPainterPath [as 别名]
# 或者: from PySide.QtGui.QPainterPath import moveTo [as 别名]
 def setupPaint(self):
     """Draw the wire segments and handle."""
     if not self.data['startIO'] or not self.data['endIO']:
         self.setPen(QPen(QBrush(QColor(QColor('black'))), 2))
     elif self.data['startIO'].value:
         self.setPen(QPen(QBrush(QColor(QColor('green'))), 2))
     else:
         self.setPen(QPen(QBrush(QColor(QColor('red'))), 2))
     path = QPainterPath()
     path.moveTo(self.data['points'][0])
     for p in self.data['points'][1:]:
         path.lineTo(p)
     if not self.complete:   # An incomplete wire needs a handle
         path.addEllipse(self.data['points'][-1], self.radius, self.radius)
     self.setPath(path)
     self.update()

# 需要导入模块: from PySide.QtGui import QPainterPath [as 别名]
# 或者: from PySide.QtGui.QPainterPath import moveTo [as 别名]
 def reshape(self):
     ''' Update the connection or arrow shape '''
     shape = QPainterPath()
     shape.moveTo(self.start_point)
     for point in self.middle_points:
         shape.lineTo(point)
     shape.lineTo(self.end_point)
     # If required draw an arrow head (e.g. in SDL NEXTSTATE and JOIN)
     if self.child.arrow_head:
         self.draw_arrow_head(shape, origin='head',
                              kind=self.child.arrow_head)
     if self.child.arrow_tail:
         shape.moveTo(shape.pointAtPercent(0))
         self.draw_arrow_head(shape, origin='tail',
                              kind=self.child.arrow_head)
     self.setPath(shape)

# 需要导入模块: from PySide.QtGui import QPainterPath [as 别名]
# 或者: from PySide.QtGui.QPainterPath import moveTo [as 别名]
 def draw_edge(self, painter, option, edge, lane_offset):
     from_y = 0.5 + lane_offset
     to_y = 1 + from_y
     pen = QPen(self.edge_color(edge.color), self.edge_thickness,
         Qt.SolidLine, Qt.FlatCap, Qt.RoundJoin)
     painter.setPen(pen)
     if edge.from_lane == edge.to_lane:
         line_x = edge.from_lane + 0.5
         painter.drawLine(QPointF(line_x, from_y), QPointF(line_x, to_y))
     else:
         from_x = edge.from_lane + 0.5
         to_x = edge.to_lane + 0.5
         path = QPainterPath()
         path.moveTo(QPointF(from_x, from_y))
         path.cubicTo(from_x, from_y + 0.5, to_x, to_y - 0.5, to_x, to_y)
         painter.drawPath(path)

# 需要导入模块: from PySide.QtGui import QPainterPath [as 别名]
# 或者: from PySide.QtGui.QPainterPath import moveTo [as 别名]
 def updatePath(self):
     """
     TOWRITE
     """
     path = QPainterPath()
     r = self.rect()  # QRectF
     path.moveTo(r.bottomLeft())
     path.lineTo(r.bottomRight())
     path.lineTo(r.topRight())
     path.lineTo(r.topLeft())
     path.lineTo(r.bottomLeft())
     # NOTE: Reverse the path so that the inside area isn't considered part of the rectangle
     path.lineTo(r.topLeft())
     path.lineTo(r.topRight())
     path.lineTo(r.bottomRight())
     path.moveTo(r.bottomLeft())
     self.setObjectPath(path)

# 需要导入模块: from PySide.QtGui import QPainterPath [as 别名]
# 或者: from PySide.QtGui.QPainterPath import moveTo [as 别名]
    def setLineFromXXYY(self, x1, y1, x2, y2):
        """
        TOWRITE

        :param `x1`: TOWRITE
        :type `x1`: qreal
        :param `y1`: TOWRITE
        :type `y1`: qreal
        :param `x2`: TOWRITE
        :type `x2`: qreal
        :param `y2`: TOWRITE
        :type `y2`: qreal
        """
        p = QPainterPath()
        p.moveTo(x1, y1)
        p.lineTo(x2, y2)
        self.setPath(p)
        self.objLine.setLine(x1, y1, x2, y2)