我们从Python开源项目中，提取了以下50个代码示例，用于说明如何使用PyQt5.QtCore.QPointF()。
def generateNodes(count, offset, depth): for i in range(count): node1 = Node(graph, 'node' + str(depth) + str(i)) node1.addPort(InputPort(node1, graph, 'InPort', QtGui.QColor(128, 170, 170, 255), 'MyDataX')) node1.addPort(OutputPort(node1, graph, 'OutPort', QtGui.QColor(32, 255, 32, 255), 'MyDataX')) node1.setNodePos(QtCore.QPointF(offset, i * 100)) graph.addNode(node1) global totalCount totalCount += 1 if depth < 6: generateNodes(count * 2, offset+160, depth+1) for i in range(count): graph.connectPorts('node' + str(depth) + str(i), 'OutPort', 'node' + str(depth+1) + str(i*2), 'InPort') graph.connectPorts('node' + str(depth) + str(i), 'OutPort', 'node' + str(depth+1) + str(i*2+1), 'InPort') elif depth < 12: generateNodes(int(count / 2), offset+160, depth+1) for i in range(count//2): graph.connectPorts('node' + str(depth) + str(i), 'OutPort', 'node' + str(depth+1) + str(int(i)), 'InPort')
def mouseMoveEvent(self, event): if self.__dragging: newPos = self.mapToScene(event.pos()) graph = self.getGraph() if graph.getSnapToGrid() is True: gridSize = graph.getGridSize() newNodePos = newPos - self._mouseDelta snapPosX = math.floor(newNodePos.x() / gridSize) * gridSize snapPosY = math.floor(newNodePos.y() / gridSize) * gridSize snapPos = QtCore.QPointF(snapPosX, snapPosY) newPosOffset = snapPos - newNodePos newPos = newPos + newPosOffset delta = newPos - self._lastDragPoint self.__graph.moveSelectedNodes(delta) self._lastDragPoint = newPos self._nodesMoved = True else: super(Node, self).mouseMoveEvent(event)
def initializeProperty(self, property): if (self.propertyType(property) == QVariant.PointF): d = VariantManager.Data() d.value = QVariant(QPointF(0, 0)) d.x = self.addProperty(QVariant.Double) d.x.setPropertyName(self.tr("Position X")) property.addSubProperty(d.x) self.xToProperty[d.x] = property d.y = self.addProperty(QVariant.Double) d.y.setPropertyName(self.tr("Position Y")) property.addSubProperty(d.y) self.yToProperty[d.y] = property self.propertyToData[property] = d super(VariantManager, self).initializeProperty(property)
def transfer(): global epi_x, epi_y, p1, p2, p3, p4, rect write_log() dx = window.spin_trans_x.value() dy = window.spin_trans_y.value() scene.clear() p1 = [p1[0] + dx, p1[1] + dy] p2 = [p2[0] + dx, p2[1] + dy] p3 = [p3[0] + dx, p3[1] + dy] p4 = [p4[0] + dx, p4[1] + dy] rect[0] = QPointF(p1[0], p1[1]) rect[1] = QPointF(p2[0], p2[1]) rect[2] = QPointF(p3[0], p3[1]) rect[3] = QPointF(p4[0], p4[1]) scene.addPolygon(rect, pen=p, brush=b) epi_x = [x + dx for x in epi_x] epi_y = [y + dy for y in epi_y] l = len(epi_x) for i in range(l): scene.addLine(epi_x[i], epi_y[i], epi_x[i] + 0.01, epi_y[i] + 0.01, pen=p)
def set(): global epi_x, epi_y, p1, p2, p3, p4, rect scene.clear() dx = 500 dy = 500 kx = 10 ky = 10 p1 = [-10 * kx + dx, -10 * ky + dy] p2 = [-10 * kx + dx + 20 * kx, -10 * ky + dy] p3 = [-10 * kx + dx + 20 * kx, -10 * ky + dy + 20 * ky] p4 = [-10 * kx + dx, -10 * ky + dy + 20 * ky] rect[0] = QPointF(p1[0], p1[1]) rect[1] = QPointF(p2[0], p2[1]) rect[2] = QPointF(p3[0], p3[1]) rect[3] = QPointF(p4[0], p4[1]) epi_x = [] epi_y = [] scene.addPolygon(rect, pen=p, brush=b) for t in np.arange(0, 4 * math.pi, 0.001): x = 5 * math.cos(t) * kx - 2 * math.cos(5 / 2 * t) * kx + dx y = 5 * math.sin(t) * ky - 2 * math.sin(5 / 2 * t) * ky + dy epi_x.append(x) epi_y.append(y) scene.addLine(x, y, x + 0.01, y + 0.01, pen=p)
def undo(): global b_epi_x, b_epi_y, b1, b2, b3, b4, epi_x, epi_y, p1, p2, p3, p4, btn_undo epi_x = b_epi_x epi_y = b_epi_y p1 = b1 p2 = b2 p3 = b3 p4 = b4 rect[0] = QPointF(p1[0], p1[1]) rect[1] = QPointF(p2[0], p2[1]) rect[2] = QPointF(p3[0], p3[1]) rect[3] = QPointF(p4[0], p4[1]) scene.clear() scene.addPolygon(rect, pen=p, brush=b) l = len(epi_x) for i in range(l): scene.addLine(epi_x[i], epi_y[i], epi_x[i] + 0.01, epi_y[i] + 0.01, pen=p)
def update(self, pos=None): path = QPainterPath() if pos is not None: if self.ioend is None: startpos = self.iostart.pos() + self.iostart.parent.pos() endpos = pos elif self.iostart is None: startpos = pos endpos = self.ioend.pos() + self.ioend.parent.pos() else: startpos = self.iostart.pos() + self.iostart.parent.pos() endpos = self.ioend.pos() + self.ioend.parent.pos() controlpoint = QPointF(abs((endpos - startpos).x()) * 0.8, 0) path.moveTo(startpos) path.cubicTo(startpos + controlpoint, endpos - controlpoint, endpos) self.setPath(path)
def __init__(self, startp=Point(), endp=None, length=60.0, angle=50.0, color=QtCore.Qt.red, pencolor=QtCore.Qt.green, startarrow=True): """ Initialisation of the class. """ self.sc = None super(Arrow, self).__init__() self.startp = QtCore.QPointF(startp.x, -startp.y) self.endp = endp self.length = length self.angle = angle self.startarrow = startarrow self.allwaysshow = False self.arrowHead = QPolygonF() self.setFlag(QGraphicsItem.ItemIsSelectable, False) self.myColor = color self.pen = QPen(pencolor, 1, QtCore.Qt.SolidLine) self.pen.setCosmetic(True) self.arrowSize = 8.0
def boundingRect(self): """ Override inherited function to enlarge selection of Arrow to include all @param flag: The flag to enable or disable Selection """ if not self.sc: # since this function is called before paint; and scale is unknown return QtCore.QRectF(self.startp.x(), self.startp.y(), 1e-9, 1e-9) arrowSize = self.arrowSize / self.sc extra = arrowSize # self.pen.width() + if self.endp is None: dx = cos(self.angle) * self.length / self.sc dy = sin(self.angle) * self.length / self.sc endp = QtCore.QPointF(self.startp.x() - dx, self.startp.y() + dy) else: endp = QtCore.QPointF(self.endp.x, -self.endp.y) brect = QtCore.QRectF(self.startp, QtCore.QSizeF(endp.x()-self.startp.x(), endp.y()-self.startp.y())).normalized().adjusted(-extra, -extra, extra, extra) return brect
def __init__(self, text='S', startp=Point(x=0.0, y=0.0),): """ Initialisation of the class. """ QGraphicsItem.__init__(self) self.setFlag(QGraphicsItem.ItemIsSelectable, False) self.text = text self.sc = 1.0 self.startp = QtCore.QPointF(startp.x, -startp.y) pencolor = QColor(0, 200, 255) self.brush = QColor(0, 100, 255) self.pen = QPen(pencolor, 1, QtCore.Qt.SolidLine) self.pen.setCosmetic(True) self.path = QPainterPath() self.path.addText(QtCore.QPointF(0, 0), QFont("Arial", 10/self.sc), self.text)
def adjust(self): if not self.source or not self.dest: return line = QLineF(self.mapFromItem(self.source, 0, 0), self.mapFromItem(self.dest, 0, 0)) length = line.length() self.prepareGeometryChange() if length > 20.0: edgeOffset = QPointF((line.dx() * 10) / length, (line.dy() * 10) / length) self.sourcePoint = line.p1() + edgeOffset self.destPoint = line.p2() - edgeOffset else: self.sourcePoint = line.p1() self.destPoint = line.p1()
def renderEdge(self, eid, einfo, points): scene = self.scene() # If we have been drawn already, get rid of it. gproxy = einfo.get('gproxy') if gproxy: scene.removeItem(gproxy) qpoints = [QtCore.QPointF(x, y) for (x, y) in points] qpoly = QtGui.QPolygonF(qpoints) ecolor = self._vg_graph.getMeta('edgecolor', '#000') ecolor = einfo.get('color', ecolor) pen = QtGui.QPen(QtGui.QColor(ecolor)) gproxy = self.scene().addPolygon(qpoly, pen=pen) gproxy.setZValue(-1.0) einfo['gproxy'] = gproxy
def update_geometry(self): self.clip_rect = QClippingPath.calculate_clipping_area( self.path().boundingRect(), self.clip_start_x, self.clip_width, self.pen().width()) self.bounding_rect = QClippingPath.calculate_bounding_rect( self.path().boundingRect(), self.clip_start_x, self.clip_width, self.pen().width()) if self.clip_start_x is not None: self.painter_offset = QtCore.QPointF( -1 * GraphicUnit(self.clip_start_x).value, 0) else: self.painter_offset = None self.prepareGeometryChange()
def __init__(self, *args, origin_offset=None, scale_factor=1, clip_start_x=None, clip_width=None, **kwargs): """ Args: origin_offset (QPointF): The offset of the glyph's origin from (0, 0) scale_factor (float): A hard scaling factor. clip_start_x (Unit or None): The local starting position for the clipping region. Use `None` to render from the start. clip_width (Unit or None): The width of the clipping region. Use `None` to render to the end All other args are passed directly to QGraphicsSimpleTextItem """ super().__init__(*args, **kwargs) self.origin_offset = origin_offset self.scale_factor = scale_factor self.clip_start_x = clip_start_x self.clip_width = clip_width self.update_geometry()
def animate(self): self.angle += (math.pi / 30) xs = 200 * math.sin(self.angle) - 40 + 25 ys = 200 * math.cos(self.angle) - 40 + 25 self.m_lightSource.setPos(xs, ys) for item in self.m_items: effect = item.graphicsEffect() delta = QPointF(item.x() - xs, item.y() - ys) effect.setOffset(QPointF(delta.toPoint() / 30)) dd = math.hypot(delta.x(), delta.y()) color = effect.color() color.setAlphaF(max(0.4, min(1 - dd / 200.0, 0.7))) effect.setColor(color) self.m_scene.update()
def setPosUsingSheepDog(self, dest, sceneFence): self.setPos(dest) if sceneFence.isNull(): return itemWidth = self.boundingRect().width() itemHeight = self.boundingRect().height() fenceRight = sceneFence.x() + sceneFence.width() fenceBottom = sceneFence.y() + sceneFence.height() if self.scenePos().x() < sceneFence.x(): self.moveBy(self.mapFromScene(QPointF(sceneFence.x(), 0)).x(), 0) if self.scenePos().x() > fenceRight - itemWidth: self.moveBy(self.mapFromScene(QPointF(fenceRight - itemWidth, 0)).x(), 0) if self.scenePos().y() < sceneFence.y(): self.moveBy(0, self.mapFromScene(QPointF(0, sceneFence.y())).y()) if self.scenePos().y() > fenceBottom - itemHeight: self.moveBy(0, self.mapFromScene(QPointF(0, fenceBottom - itemHeight)).y())
def setupScanItem(self): if Colors.useButtonBalls: scanItem = ScanItem(self) scanItem.setZValue(self.zValue() + 1) self.scanAnim = DemoItemAnimation(scanItem) x = 1.0 y = 1.5 stop = TextButton.BUTTON_WIDTH - scanItem.boundingRect().width() - x if self.alignment == TextButton.LEFT: self.scanAnim.setDuration(2500) self.scanAnim.setKeyValueAt(0.0, QPointF(x, y)) self.scanAnim.setKeyValueAt(0.5, QPointF(x, y)) self.scanAnim.setKeyValueAt(0.7, QPointF(stop, y)) self.scanAnim.setKeyValueAt(1.0, QPointF(x, y)) scanItem.setPos(QPointF(x, y)) else: self.scanAnim.setKeyValueAt(0.0, QPointF(stop, y)) self.scanAnim.setKeyValueAt(0.5, QPointF(x, y)) self.scanAnim.setKeyValueAt(1.0, QPointF(stop, y)) scanItem.setPos(QPointF(stop, y))
def _draw_video_pos(self, painter): if not self._api.video.current_pts: return x = self._pts_to_x(self._api.video.current_pts) painter.setPen(QtCore.Qt.NoPen) painter.setBrush(get_color(self._api, 'spectrogram/video-marker')) width = 7 polygon = QtGui.QPolygonF() for x, y in [ (x - width / 2, 0), (x + width / 2, 0), (x + width / 2, SLIDER_SIZE), (x + 1, SLIDER_SIZE + width / 2), (x + 1, painter.viewport().height() - 1), (x, painter.viewport().height() - 1), (x, SLIDER_SIZE + width / 2), (x - width / 2, SLIDER_SIZE), ]: polygon.append(QtCore.QPointF(x, y)) painter.drawPolygon(polygon)
def _add_latest_input_line(self, angle): """Adds a line to the graphic scene that visualizes a scanned angle""" mx, my = self._get_middle() angle_rad = deg2rad(angle) angle_1_rad = deg2rad(angle - self.measurement_angle/2.0) angle_2_rad = deg2rad(angle + self.measurement_angle/2.0) length = max(self.width(), self.height()) start_point = (mx, my) p1 = (mx + length * math.cos(angle_1_rad), my + length * math.sin(angle_1_rad)) p2 = (mx + length * math.cos(angle_2_rad), my + length * math.sin(angle_2_rad)) gradient_start_point, gradient_end_point = (mx, my), (mx + length * math.cos(angle_rad), my + length * math.sin(angle_rad)) gradient = QLinearGradient(*gradient_start_point, *gradient_end_point) gradient.setColorAt(0, Qt.transparent) gradient.setColorAt(0.8, Qt.red) gradient.setColorAt(1, Qt.darkRed) triangle = QPolygonF() triangle.append(QPointF(*start_point)) triangle.append(QPointF(*p1)) triangle.append(QPointF(*p2)) triangle.append(QPointF(*start_point)) self.scene.addPolygon(triangle, pen=QPen(Qt.transparent), brush=QBrush(gradient))
def paint(self, painter, option, widget): srcPoint = self.mapFromScene(self.__srcPortCircle.centerInSceneCoords()) dstPoint = self.mapFromScene(self.__dstPortCircle.centerInSceneCoords()) dist_between = dstPoint - srcPoint self.__path = QtGui.QPainterPath() self.__path.moveTo(srcPoint) self.__path.cubicTo( srcPoint + QtCore.QPointF(0, 0), dstPoint - QtCore.QPointF(0, 0), dstPoint ) self.setPath(self.__path) super(Connection, self).paint(painter, option, widget)
def getGraphPos(self): transform = self.transform() size = self.size() return QtCore.QPointF(transform.dx()+(size.width()*0.5), transform.dy()+(size.height()*0.5))
def setDragPoint(self, dragPoint): topLeft = QtCore.QPointF(self.__mouseDownPos) bottomRight = QtCore.QPointF(dragPoint) if dragPoint.x() < self.__mouseDownPos.x(): topLeft.setX(dragPoint.x()) bottomRight.setX(self.__mouseDownPos.x()) if dragPoint.y() < self.__mouseDownPos.y(): topLeft.setY(dragPoint.y()) bottomRight.setY(self.__mouseDownPos.y()) self.setPos(topLeft) self.resize(bottomRight.x() - topLeft.x(), bottomRight.y() - topLeft.y())
def to_qvector(value): """ Converts a vector-like object to QPointF. """ return QPointF(*value)
def from_qvector(value): """ Converts a QPointF to a Vec. """ return Vec(value.x(), value.y())
def scale(): global epi_x, epi_y, p1, p2, p3, p4, rect write_log() kx = window.spin_kx.value() sc_x = window.spin_scl_x.value() sc_y = window.spin_scl_y.value() ky = window.spin_ky.value() #print(kx, ky) scene.clear() epi_x = [x * kx + (1 - kx) * sc_x for x in epi_x] epi_y = [y * ky + (1 - ky) * sc_y for y in epi_y] p1 = [p1[0] * kx + (1 - kx) * sc_x, p1[1] * ky + (1 - ky) * sc_y] p2 = [p2[0] * kx + (1 - kx) * sc_x, p2[1] * ky + (1 - ky) * sc_y] p3 = [p3[0] * kx + (1 - kx) * sc_x, p3[1] * ky + (1 - ky) * sc_y] p4 = [p4[0] * kx + (1 - kx) * sc_x, p4[1] * ky + (1 - ky) * sc_y] #print(p1.x) rect[0] = QPointF(p1[0], p1[1]) rect[1] = QPointF(p2[0], p2[1]) rect[2] = QPointF(p3[0], p3[1]) rect[3] = QPointF(p4[0], p4[1]) scene.addPolygon(rect, pen=p, brush=b) l = len(epi_x) for i in range(l): scene.addLine(epi_x[i], epi_y[i], epi_x[i] + 0.01, epi_y[i] + 0.01, pen=p)
def turn(): global epi_x, epi_y, p1, p2, p3, p4, rect write_log() teta = math.radians(window.spin_deg.value()) t_x = window.spin_turn_x.value() t_y = window.spin_turn_y.value() scene.clear() rect_t = QPolygonF(4) p1 = [t_x + (p1[0] - t_x) * math.cos(teta) + (p1[1] - t_y) * math.sin(teta), t_y - (p1[0] - t_x) * math.sin(teta) + (p1[1] - t_y) * math.cos(teta)] p2 = [t_x + (p2[0] - t_x) * math.cos(teta) + (p2[1] - t_y) * math.sin(teta), t_y - (p2[0] - t_x) * math.sin(teta) + (p2[1] - t_y) * math.cos(teta)] p3 = [t_x + (p3[0] - t_x) * math.cos(teta) + (p3[1] - t_y) * math.sin(teta), t_y - (p3[0] - t_x) * math.sin(teta) + (p3[1] - t_y) * math.cos(teta)] p4 = [t_x + (p4[0] - t_x) * math.cos(teta) + (p4[1] - t_y) * math.sin(teta), t_y - (p4[0] - t_x) * math.sin(teta) + (p4[1] - t_y) * math.cos(teta)] rect[0] = QPointF(p1[0], p1[1]) rect[1] = QPointF(p2[0], p2[1]) rect[2] = QPointF(p3[0], p3[1]) rect[3] = QPointF(p4[0], p4[1]) scene.addPolygon(rect, pen=p, brush=b) l = len(epi_x) for i in range(l): x1 = t_x + (epi_x[i] - t_x) * math.cos(teta) + (epi_y[i] - t_y) * math.sin(teta) y1 = t_y - (epi_x[i] - t_x) * math.sin(teta) + (epi_y[i] - t_y) * math.cos(teta) epi_x[i] = x1 epi_y[i] = y1 scene.addLine(epi_x[i], epi_y[i], epi_x[i] + 0.01, epi_y[i] + 0.01, pen=p)
def __init__(self, listItem:QListWidgetItem, propertiesDockWidget:QDockWidget, sendMessageCallback, data=None): self.sendMessageCallback = sendMessageCallback self.scene = QNodeScene(ModulePickerDialog(sendMessageCallback)) self.view = QNodeView() self.view.setScene(self.scene) self.scene.setSceneRect(-2500, -2500, 5000, 5000) # TODO: Make this less shitty self.listItem = listItem self.id = self.listItem.data(Qt.UserRole) # Get ID from the listitem self.dockWidget = propertiesDockWidget self.availableModules = searchModules() self.scene.selectionChanged.connect(self.sceneSelectionChanged) self.sheetMap = {} # key: sheetid, value: sheetname special thing for subsheets so you can pick a subsheet. FIXME: Make this less special-casey # --- Pass scene changes self.sceneUndoStackIndexChangedCallback = None self.scene.undostack.indexChanged.connect(self.sceneUndoStackIndexChanged) self.workerManagerSendNodeData = None if data is not None: self.deserialize(data) else: self.initnode = InitNode() self.scene.addItem(self.initnode) self.loopnode = LoopNode() self.scene.addItem(self.loopnode) self.loopnode.setPos(QPointF(0, 100)) self.name = self.listItem.text()
def __init__(self, iostart=None, ioend=None): super().__init__() self.setEnabled(False) # Make it ignore events. Links can't be interacted with. self.iostart = iostart self.ioend = ioend if iostart is not None and ioend is not None: self.update() else: self.update(QPointF(0, 0))
def mousePressEvent(self, event): if event.button() == Qt.LeftButton: if self.iodir == "output": self.newbezier = Node.io.BezierCurve(self, None) elif self.iodir == "input": self.newbezier = Node.io.BezierCurve(None, self) if self.newbezier is not None: self.newbezier.update(QPointF(event.pos() + self.pos() + self.parent.pos())) self.parent.parent.scene.addItem(self.newbezier) elif event.button() == Qt.RightButton: self.delAllBezier()
def intersectLineGeometry(self, lineGeo, breakShape): """ Try to break lineGeo with the given breakShape. Will return the intersection points of lineGeo with breakShape. """ # TODO geos should be abs intersections = [] line = QLineF(lineGeo.Ps.x, lineGeo.Ps.y, lineGeo.Pe.x, lineGeo.Pe.y) for breakGeo in breakShape.geos.abs_iter(): if isinstance(breakGeo, LineGeo): breakLine = QLineF(breakGeo.Ps.x, breakGeo.Ps.y, breakGeo.Pe.x, breakGeo.Pe.y) intersection = QPointF(0, 0) # values do not matter res = line.intersect(breakLine, intersection) if res == QLineF.BoundedIntersection: intersections.append(Point(intersection.x(), intersection.y())) return intersections
def draw_wp_zero(self): """ This function is called while the drawing of all items is done. It plots the WPZero to the Point x=0 and y=0. This item will be enabled or disabled to be shown or not. """ self.wpzero = WpZero(QtCore.QPointF(0, 0)) self.addItem(self.wpzero)
def __init__(self, sourceNode, destNode): super(VGraphEdge, self).__init__() self.arrowSize = 10.0 self.sourcePoint = QPointF() self.destPoint = QPointF() self.setAcceptedMouseButtons(Qt.NoButton) self.source = sourceNode self.dest = destNode self.source.addEdge(self) self.dest.addEdge(self) self.adjust()
def paint(self, painter, option, widget): if not self.source or not self.dest: return # Draw the line itself. line = QLineF(self.sourcePoint, self.destPoint) if line.length() == 0.0: return painter.setPen(QPen(Qt.black, 1, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin)) painter.drawLine(line) # Draw the arrows if there's enough room. angle = math.acos(line.dx() / line.length()) if line.dy() >= 0: angle = VGraphEdge.TwoPi - angle sourceArrowP1 = self.sourcePoint + QPointF(math.sin(angle + VGraphEdge.Pi / 3) * self.arrowSize, math.cos(angle + VGraphEdge.Pi / 3) * self.arrowSize) sourceArrowP2 = self.sourcePoint + QPointF(math.sin(angle + VGraphEdge.Pi - VGraphEdge.Pi / 3) * self.arrowSize, math.cos(angle + VGraphEdge.Pi - VGraphEdge.Pi / 3) * self.arrowSize); destArrowP1 = self.destPoint + QPointF(math.sin(angle - VGraphEdge.Pi / 3) * self.arrowSize, math.cos(angle - VGraphEdge.Pi / 3) * self.arrowSize) destArrowP2 = self.destPoint + QPointF(math.sin(angle - VGraphEdge.Pi + VGraphEdge.Pi / 3) * self.arrowSize, math.cos(angle - VGraphEdge.Pi + VGraphEdge.Pi / 3) * self.arrowSize) painter.setBrush(Qt.black) painter.drawPolygon(QPolygonF([line.p1(), sourceArrowP1, sourceArrowP2])) painter.drawPolygon(QPolygonF([line.p2(), destArrowP1, destArrowP2]))
def fitScaleMetrics(self): """ Scales and centers the viewport around the font’s metrics. """ scrollArea = self._scrollArea if scrollArea: fitHeight = scrollArea.viewport().height() else: fitHeight = self.height() glyphWidth, glyphHeight = self._getGlyphWidthHeight() glyphHeight += self._noPointSizePadding * 2 self.setScale(fitHeight / glyphHeight) self.centerOn(self.mapFromCanvas( QPointF(glyphWidth / 2, self._descender + self._unitsPerEm / 2)))
def fitScaleBBox(self): """ Scales and centers the viewport around the *glyph*’s bounding box. """ if self._glyph is None: return if self._glyph.bounds is None: self.fitScaleMetrics() return scrollArea = self._scrollArea if scrollArea: viewport = scrollArea.viewport() fitHeight = viewport.height() fitWidth = viewport.width() else: fitHeight = self.height() fitWidth = self.width() left, bottom, right, top = self._glyph.bounds glyphHeight = top - bottom glyphHeight += self._noPointSizePadding * 2 glyphWidth = right - left glyphWidth += self._noPointSizePadding * 2 self.setScale(min( fitHeight / glyphHeight, fitWidth / glyphWidth)) self.centerOn(self.mapFromCanvas( QPointF(left + (right - left) / 2, bottom + (top - bottom) / 2))) self.pointSizeModified.emit(self._impliedPointSize)
def mapRectFromCanvas(self, rect): x, y, w, h = rect.getRect() origin = self.mapFromCanvas(QPointF(x, y)) w *= self._scale h *= self._scale return rect.__class__(origin.x(), origin.y() - h, w, h)
def mapRectToCanvas(self, rect): x, y, w, h = rect.getRect() origin = self.mapToCanvas(QPointF(x, y)) w *= self._inverseScale h *= self._inverseScale return rect.__class__(origin.x(), origin.y() - h, w, h) # -------------------- # Notification Support # --------------------
def calculate_clip_offset(self): if self.clip_start_x is not None: main_offset = QtCore.QPointF( -1 * unit_to_qt_float(self.clip_start_x / self.scale_factor), 0) else: main_offset = QtCore.QPointF(0, 0) return (self.origin_offset * -1) + main_offset
def qt_point_to_point(qt_point, unit=None): """Create a Point from a QPoint or QPointF Args: qt_point (QPoint or QPointF): The source point unit (Unit): An optional unit to convert values to in the output `Point`. If omitted, values in the output `Point` will be plain `int` or `float` values. Returns: Point """ if unit: return Point(qt_point.x(), qt_point.y()).to_unit(unit) else: return Point(qt_point.x(), qt_point.y())
def point_to_qt_point_f(point): """Create a QPointF from a Point Args: point (Point): The source point Returns: QPointF """ return QPointF(unit_to_qt_float(point.x), unit_to_qt_float(point.y))
def test_pos_setter_changesqt_object(self): grob = MockGraphicObjectInterface( None, (GraphicUnit(0), GraphicUnit(0))) grob.pos = (GraphicUnit(10), GraphicUnit(11)) expected = QPointF(10, 11) assert(grob.x == grob.pos.x) assert(grob.y == grob.pos.y) self.assertAlmostEqual(expected.x(), grob.qt_object.x()) self.assertAlmostEqual(expected.y(), grob.qt_object.y())
def test_x_setter_changesqt_object(self): grob = MockGraphicObjectInterface( None, (GraphicUnit(5), GraphicUnit(6))) grob.x = GraphicUnit(100) expected = QPointF(100, 6) self.assertAlmostEqual(expected.x(), grob.qt_object.x()) self.assertAlmostEqual(expected.y(), grob.qt_object.y())
def test_y_setter_changesqt_object(self): grob = MockGraphicObjectInterface( None, (GraphicUnit(5), GraphicUnit(6))) grob.y = GraphicUnit(100) expected = QPointF(5, 100) self.assertAlmostEqual(expected.x(), grob.qt_object.x()) self.assertAlmostEqual(expected.y(), grob.qt_object.y())
def test_qt_point_to_point_with_q_point_f(): point = qt_point_to_point(QPointF(1.5, 2.5)) assert(isinstance(point, Point)) assert(point.x == 1.5) assert(point.y == 2.5)
