def __init__(self, *args): QGraphicsScene.__init__(self, *args) # Add a graphic item, not responsive to gestures?? text = QGraphicsTextItem("Test") text.setTextInteractionFlags(Qt.TextEditorInteraction) self.addItem(text)
class ActionItem(GraphicsItem): def __init__(self, model_item: SimulatorItem, parent=None): super().__init__(model_item=model_item, parent=parent) self.setFlag(QGraphicsTextItem.ItemIsPanel, True) self.text = QGraphicsTextItem(self) self.text.setFont(self.font) def update_flags(self): if self.scene().mode == 0: self.set_flags(is_selectable=True, is_movable=True, accept_hover_events=True, accept_drops=True) def update_position(self, x_pos, y_pos): self.setPos(x_pos, y_pos) start_x = (self.scene().items_width() - self.labels_width()) / 2 self.number.setPos(start_x, 0) start_x += self.number.boundingRect().width() self.text.setPos(start_x, 0) width = self.scene().items_width() self.prepareGeometryChange() self.bounding_rect = QRectF(0, 0, width, self.childrenBoundingRect().height() + 5) def labels_width(self): width = self.number.boundingRect().width() width += self.text.boundingRect().width() return width
def __init__(self, dir_assets, *args): super().__init__(*args) self.name = "Jugador {0}".format(Main_Player.contador) self.sprite_generator = sprite_generator(dir_assets, 7, 8) next(self.sprite_generator) self.experience = 0 self.progress_bar = Progress_Bar(1000) self.set_health_var() self.set_pixmap_image() self.set_attack_timer() self.set_animation_timer() self.attack_velocity = 1000 self.move = True self.atacar = True self.level_impar = False self.set_movement_timer() self.setTransformOriginPoint(50 * self.ponderador, 50 * self.ponderador) self.score = 0 self.set_score_timer() self.score_label = QGraphicsTextItem() self.score_label.setDefaultTextColor(QColor("green")) Main_Player.contador += 1
def drawNode(self, index, node_pos, is_near): # 样式设置 node_draw_r = 15 node_draw_x = node_pos.x() - node_draw_r node_draw_y = node_pos.y() - node_draw_r # node_draw_pos = QPointF(node_draw_x, node_draw_y) node_draw_pen = QPen(QColor(204, 47, 105), 3, Qt.SolidLine) node_draw_brush = QBrush(QColor(255, 110, 151), Qt.SolidPattern) # 正式画圆 self.gellipse_node = self.gscene_map.addEllipse( node_draw_x, node_draw_y, 2 * node_draw_r, 2 * node_draw_r, node_draw_pen, node_draw_brush) # 索引号 self.text_index = '<div style=\"font:26px;color:black;font-weight:900;\">' + \ str(index) + '</div>' self.gtext_index = QGraphicsTextItem() self.gtext_index.setHtml(self.text_index) self.gtext_index.setParentItem(self.gellipse_node) self.gtext_index.setPos(node_draw_x + 4, node_draw_y - 2) if is_near: # 若附近rssi判断有效 node_draw_r = 20 node_draw_x = node_pos.x() - node_draw_r node_draw_y = node_pos.y() - node_draw_r node_draw_pen = QPen(QColor(245, 229, 143), 10, Qt.DashLine) self.gscene_map.addEllipse(node_draw_x, node_draw_y, 2 * node_draw_r, 2 * node_draw_r, node_draw_pen)
class ActionItem(GraphicsItem): def __init__(self, model_item: SimulatorItem, parent=None): super().__init__(model_item=model_item, parent=parent) self.setFlag(QGraphicsTextItem.ItemIsPanel, True) self.text = QGraphicsTextItem(self) self.text.setFont(GraphicsItem.font) def update_flags(self): if self.scene().mode == 0: self.set_flags(is_selectable=True, is_movable=True, accept_hover_events=True, accept_drops=True) def update_position(self, x_pos, y_pos): self.setPos(x_pos, y_pos) start_x = (self.scene().items_width() - self.labels_width()) / 2 self.number.setPos(start_x, 0) start_x += self.number.boundingRect().width() self.text.setPos(start_x, 0) width = self.scene().items_width() self.prepareGeometryChange() self.bounding_rect = QRectF(0, 0, width, self.childrenBoundingRect().height() + 5) #super().update_position(x_pos, y_pos) def labels_width(self): width = self.number.boundingRect().width() #width += 5 width += self.text.boundingRect().width() return width
def __showCircle(self): ratio = 3 pen = QPen() pen.setBrush(Qt.red) pen.setWidth(0.01) font = QFont() font.setPointSize(200 * ratio) self.scene.clear() for i in range(len(self.pointsXYItem)): (x, y) = self.pointsXYItem[i] r = self.radius[i] * ratio circleItem = QGraphicsEllipseItem(x - r, y - r, 2 * r, 2 * r) circleItem.setPen(pen) self.scene.addItem(circleItem) strItem = QGraphicsTextItem() strItem.setDefaultTextColor(Qt.blue) strItem.setFont(font) strItem.setPlainText(self.pointsName[i]) strItem.setPos(x, y) self.scene.addItem(strItem)
def __init__(self, *args): self.__boundingRect = None QGraphicsObject.__init__(self, *args) self.setFlag(QGraphicsItem.ItemHasNoContents, True) self.setAcceptedMouseButtons(Qt.RightButton | Qt.LeftButton) self.setAcceptHoverEvents(True) self.setZValue(self.Z_VALUE) self.sourceItem = None self.sourceAnchor = None self.sinkItem = None self.sinkAnchor = None self.curveItem = LinkCurveItem(self) self.sourceIndicator = LinkAnchorIndicator(self) self.sinkIndicator = LinkAnchorIndicator(self) self.sourceIndicator.hide() self.sinkIndicator.hide() self.linkTextItem = QGraphicsTextItem(self) self.__sourceName = "" self.__sinkName = "" self.__dynamic = False self.__dynamicEnabled = False self.hover = False self.prepareGeometryChange() self.__boundingRect = None
def __init__(self): super(Video, self).__init__() self.resize(1920, 1080) # ITEM self._item = QGraphicsVideoItem() self._textItem = QGraphicsTextItem() self._view = QGraphicsView() self._scene = QGraphicsScene() self._view.resize(1920, 1080) self._view.setScene(self._scene) self._scene.addItem(self._item) self._scene.addItem(self._textItem) self._textItem.setPlainText('SRT TEXT') self._textItem.setDefaultTextColor(Qt.red) font = self._textItem.font() font.setPixelSize(50) self._textItem.setFont(font) self._view.show() self._item.setSize(QSizeF(1920, 1080)) self._player = QMediaPlayer(self) self._player.setMedia( QMediaContent( QUrl.fromLocalFile( '/Users/huangkai/Documents/PycharmProjects/AllTest/Qt插入背景/AddVideos/Videos/yellow.mov' ))) self._player.setVideoOutput(self._item) self._player.play() self.setCentralWidget(self._view) self._item.setPos(400, 500) # BUTTON self._btn = QPushButton(self) self._btn.resize(100, 50) self._btn.move(500, 500) self._btn.setText('test') self._btn.clicked.connect(self._change_text)
def __init__(self, model_item=None, prefix="", parent=None): """ Creates a visualization item. """ QAbstractGraphicsShapeItem.__init__(self, parent) self.setFlags(QGraphicsItem.ItemIsSelectable | QGraphicsItem.ItemIsMovable | QGraphicsItem.ItemSendsGeometryChanges | QGraphicsItem.ItemSendsScenePositionChanges) self._model_item = model_item if self._model_item is not None: self._model_item.model().dataChanged.connect(self.onDataChanged) # initialize members self._prefix = prefix self._auto_text_keys = self.defaultAutoTextKeys[:] self._text = "" self._text_bg_brush = None self._text_item = QGraphicsTextItem(self) self._text_item.setPos(0, 0) self._text_item.setAcceptHoverEvents(False) self._text_item.setFlags(QGraphicsItem.ItemIgnoresTransformations) self._text_item.setHtml(self._compile_text()) self._valid = True if len(self.cycleValuesOnKeypress) > 0: logging.warning( "cycleValueOnKeypress is deprecated and will be removed in the future. " + "Set BaseItem.hotkeys instead with cycleValue()") self.changeColor()
class Arc(QGraphicsLineItem): def __init__(self, first_node, second_node, weight, scene): QGraphicsLineItem.__init__(self) pen = QPen(QColor("green"), 5) self.first_node = first_node self.second_node = second_node self.weight = weight self.setZValue(1) self.setPen(pen) self.setLine(self.first_node.x() + 25, self.first_node.y() + 25, self.second_node.x() + 25, self.second_node.y() + 25) self.number = QGraphicsTextItem(str(weight)) self.number.setZValue(6) x = (first_node.x() + second_node.x()) / 2 y = (first_node.y() + second_node.y()) / 2 self.number.setPos(x, y) scene.addItem(self) scene.addItem(self.number) def __str__(self): return "{" + str(self.first_node.getNumber()) + ", " + str( self.second_node.getNumber()) + ", " + str(self.weight) + "}" def reverse(self): temp = self.first_node self.first_node = self.second_node self.second_node = temp
def __init__(self, name, index, addr, rect, text, manager): self.text = QGraphicsTextItem(text) self.text_width = self.text.boundingRect().width() if self.text_width > rect.width() - 6: rect.setWidth(self.text_width + 6) self.text_height = self.text.boundingRect().height() if self.text_height > rect.height() - 6: rect.setHeight(self.text_height + 6) super(StateNode, self).__init__(rect) self.name = name self.index = index self.addr = addr self.text.setPos(rect.topLeft() + QPointF((rect.width() - self.text_width) / 2, 0)) self.manager = manager self.setZValue(1) self.setFlag(QGraphicsItem.ItemIsMovable) self.setFlag(QGraphicsItem.ItemIsSelectable) self.setFlag(QGraphicsItem.ItemSendsGeometryChanges) self.edges = [] self.str_to_node = { 'right': self.right_node, 'top': self.top_node, 'left': self.left_node, 'down': self.down_node, 'top_left': self.tl_node, 'top_right': self.tr_node, 'down_left': self.dl_node, 'down_right': self.dr_node, }
def __init__(self, parent, text="", color=Qt.white, text_col=Qt.black): super().__init__(None) polygon = QPolygonF() self.width = 175 self.height = 24 polygon.append(QPointF(0, 0)) polygon.append(QPointF(0, self.height)) polygon.append(QPointF(self.width, self.height)) polygon.append(QPointF(self.width, 0)) self.setPolygon(polygon) # we want black background bg = QBrush() col = QColor(color) col.setAlpha(200) bg.setColor(col) bg.setStyle(Qt.SolidPattern) self.setBrush(bg) self.text = QGraphicsTextItem(self) self.text.setDefaultTextColor(QColor(text_col)) self.text.setPlainText(text) self.show()
def _showLetter(self, i, j): """ Graphical representation of a square to fill is created here. """ x = j * self.SQUARE_SIZE y = i * self.SQUARE_SIZE self.scene.addRect(x, y, self.SQUARE_SIZE, self.SQUARE_SIZE, QPen(Qt.black, 1, Qt.SolidLine), QBrush(Qt.NoBrush)) square = self.model.grid[i][j] if len(square) == 1: numberTextItem = QGraphicsTextItem(str(square[0])) numberTextItem.setDefaultTextColor(Qt.darkGreen) numberTextItem.setPos(x + self.SQUARE_SIZE / 3, y + self.SQUARE_SIZE / 3) self.scene.addItem(numberTextItem) else: for number in square: numberTextItem = QGraphicsTextItem(str(number)) xPos = x + ((number - 1) % 3) * self.SQUARE_SIZE / 3 yPos = y + ((number - 1) / 3) * self.SQUARE_SIZE / 3 numberTextItem.setPos(xPos, yPos) self.scene.addItem(numberTextItem)
def focusOutEvent(self, event): '''Handle focus out event. Argument(s): event (QFocusEvent ): Focus event ''' QGraphicsTextItem.focusOutEvent(self, event) # Create a fake node to test if label is valid with pydot fakeNode = ("fake[" + NodeDotAttrs.label.value + "=" + self.toPlainText() + "]") pydotGraph = graph_from_dot_data("graph{" + fakeNode + "}") # Label is valid: we can do the update if pydotGraph: dicDotAttrs = { NodeDotAttrs.label.value: NodeDotLabelUtils.formatLabel(self.toPlainText()) } # Update text in other views node = self.parentItem() node.graphicsGraphView.controller.onEditNode(node.id, dicDotAttrs) # Disable edit text self.setTextInteractionFlags(Qt.NoTextInteraction) # Label is invalid: force user to write a correct label else: QMessageBox.warning(None, "Syntax error", "The label is invalid.") self.setFocus()
def addGraphicsItems(self): self.mainRect = QGraphicsRectItem(QRectF(-15, -15, 30, 30), self) self.nodeTitle = QGraphicsTextItem(type(self).name, self) titleFont = QFont() titleFont.setBold(True) self.nodeTitle.setFont(titleFont) self.selectedChanged(self.isSelected())
def __init__(self, pos, size, type_, parent=None, scene=None, areaBorder=2, index=0, textSize=50): QGraphicsRectItem.__init__(self, 0, 0, size.width(), size.height(), parent) self.setPos(pos) self.newEvent = IsClicked() self.newEvent.area = self #self.setAcceptedMouseButtons(QtCore.Qt.NoButton) self.setFlags(QGraphicsItem.ItemIsMovable | QGraphicsItem.ItemIsFocusable | QGraphicsItem.ItemIsSelectable) ## set index label self.text = QGraphicsTextItem("%d" % index, self) self.setTextSize(textSize) ## TODO: How to create constants for the type? ## (such as constants in Qt) (enum?) self.kind = type_ pen = QPen(self.color, areaBorder, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin) self.setPen(pen)
def __init__(self, parent): super().__init__(parent) self.setRenderHint(QPainter.Antialiasing) self.chart = self.chart() self.chart.legend().setVisible(False) self._chart_loaded = False self._chart_horizontal_line = QGraphicsLineItem(0, 0, 0, 0) pen = self._chart_horizontal_line.pen() pen.setStyle(Qt.DashLine) self._chart_horizontal_line.setPen(pen) self.scene().addItem(self._chart_horizontal_line) self._chart_vertical_line = QGraphicsLineItem(0, 0, 0, 0) self._chart_vertical_line.setPen(pen) self.scene().addItem(self._chart_vertical_line) self._chart_tooltip = QGraphicsTextItem("") self._chart_tooltip.setPos(100, 20) self.scene().addItem(self._chart_tooltip) self._chart_crosshair = QGraphicsTextItem("") self._chart_crosshair.setPos(600, 20) self.scene().addItem(self._chart_crosshair) margins = self.chart.margins() margins.setTop(margins.top() + 80) self.chart.setMargins(margins)
def mouseDoubleClickEvent(self, event): if self.textInteractionFlags() == Qt.NoTextInteraction and \ self.interactionEnabled: self.setTextInteractionFlags(Qt.TextEditorInteraction) self.textEditStarted.emit() QGraphicsTextItem.mouseDoubleClickEvent(self, event)
def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self.setupUi(self) self.text_aligns = [ ('center', 'По центру'), ('left', 'По левому краю'), ('right', 'По правому краю'), ] self.text_align = 'center' for align, align_text in self.text_aligns: self.textPosH.addItem(align_text) self.item: QGraphicsRectItem = QGraphicsRectItem() self.main_view: QGraphicsView = QGraphicsView() self.fontSelect.currentFontChanged.connect(self.render_text) self.fontSize.valueChanged.connect(self.render_text) self.textPosH.currentTextChanged.connect(self.render_text) self.exText.textChanged.connect(self.render_text) self.font_color = QColor('black') self.scene = QGraphicsScene() self.graphicsView.setScene(self.scene) self.text = QGraphicsTextItem() self.buttonBox.accepted.connect(self.accepted) self.colorPicker.clicked.connect(self.select_color)
def __init__(self, name, height=200, width=50, parent=None): '''name: str ''' super().__init__(parent) # Set locked atribute self.locked = False # create my signal self.s = ButtonSignal() # draw the rect self.setRect(0, 0, height, width) # change color of rect brush = QBrush() brush.setStyle(Qt.SolidPattern) brush.setColor(Qt.darkCyan) self.setBrush(brush) # draw the text self.text = QGraphicsTextItem(name, self) x_pos = self.rect().width() / 2 - self.text.boundingRect().width() / 2 y_pos = self.rect().height() / 2 - self.text.boundingRect().height() / 2 self.text.setPos(x_pos, y_pos) # allow responding to hover events self.setAcceptHoverEvents(True)
def __init__(self, model_item: SimulatorItem, parent=None): super().__init__(model_item=model_item, parent=parent) self.setFlag(QGraphicsTextItem.ItemIsPanel, True) self.text = QGraphicsTextItem(self) self.text.setFont(GraphicsItem.font)
def __init__(self, parent=None): super().__init__(parent) self.view = VideoGraphicsView() self.setCentralWidget(self.view) self.view.videoItem.nativeSizeChanged.connect( self.handle_native_size_changed) url = QUrl( "https://www.learningcontainer.com/wp-content/uploads/2020/05/sample-mp4-file.mp4" ) self.view.player.setMedia(QMediaContent(url)) self.view.player.play() self.resize(640, 480) self.text_item = QGraphicsTextItem(self.view.videoItem) self.text_item.setHtml( """<div style="color: #41CD52; font-weight: bold; font-size: 20px;">Qt is awesome</div>""" ) self.text_item.hide() self.animation = QVariantAnimation() self.animation.setDuration(1000) self.animation.setStartValue(QPointF(0.0, 0.0)) self.animation.setEndValue(QPointF(0.0, 0.0)) self.animation.valueChanged.connect(self.text_item.setPos) self.animation.finished.connect(self.start_of_start_animation)
def __drawPoint(self, x, y, index): #横线 line1 = QGraphicsLineItem() line1.setPen(self.pen) line1.setLine(x - self.lineRadius, y, x + self.lineRadius, y) #竖线 line2 = QGraphicsLineItem() line2.setPen(self.pen) line2.setLine(x, y - self.lineRadius, x, y + self.lineRadius) #文字说明 text = QGraphicsTextItem() text.setDefaultTextColor(Qt.blue) text.setFont(self.font) text.setPlainText(self.pointsName[index]) text.setPos(x, y) #放到组中 pointGroup = QGraphicsItemGroup() pointGroup.addToGroup(line1) pointGroup.addToGroup(line2) pointGroup.addToGroup(text) #显示 if self.pointsItem[index] is not None: self.scene.removeItem(self.pointsItem[index]) #保存到字典 self.pointsItem[index] = pointGroup #显示该点 self.scene.addItem(self.pointsItem[index])
class ReadoutView(View): class Orientation(Enum): horizontal = 1 vertical = 2 def __init__(self, model): super().__init__(model) self.graphics_item = QGraphicsRectItem(0, 0, 9, 9) self.graphics_item.setBrush(Qt.black) inner_rect_item = QGraphicsRectItem(1, 1, 7, 7, self.graphics_item) inner_rect_item.setBrush(Qt.white) self.text_item = None self.orientation = ReadoutView.Orientation.horizontal def line(self): for child in self.graphics_item.childItems(): if isinstance(child, QGraphicsLineItem): return child.line() def line_item(self): for child in self.graphics_item.childItems(): if isinstance(child, QGraphicsLineItem): return child def init_text(self): width = self.graphics_item.boundingRect().width() height = self.graphics_item.boundingRect().height() self.text_item = QGraphicsTextItem(self.graphics_item) self.text_item.setPos(width / 2 + 2, -height)
def init(self, parent=None): QGraphicsTextItem.__init__(self, parent) self.setPlainText("Wave: 0 Score: 0") self.setFont(QFont("Robotica", 15)) self.setDefaultTextColor(QColor(255, 255, 0)) self.setPos(10, 670)
def __init__(self, row, column, enabled, *args): self._detector_id = box_id(row, column) self._enabled = enabled self._selected = False self._rect = QRectF(*args) self._rect.setHeight(self.length) self._rect.setWidth(self.length) super().__init__(self._rect) self.setPen(self.invisible_pen) self.setAcceptHoverEvents(True) if enabled: self.setBrush(self.enabled_brush) else: self.setBrush(self.disabled_brush) # states: enabled, disabled, hovered, selected self._label = QGraphicsTextItem(str(self.detector_id), self) self._label.setTransform(flip_vertical, True) self._label.setFont(QFont('Arial', 14)) self._label.setDefaultTextColor(QColor('white')) self._detector_selector = None
def _constructTree(self, node, x, y, par_x, par_y, text, squared=True, depth=1, h_index=0): if squared: node_item = BinTreeSquareNodeGraphicsItem(text, depth=depth) else: node_item = BinTreeNodeGraphicsItem(text, depth=depth) self.nodeCount += 1 node_item.setBrush(Qt.white) if node.data in self.regionPoints: node_item.setPen(Qt.green) self.addItem(node_item) node_item.moveBy(x, y) dx, dy = self.width() / (2 ** (depth + 2)), 2 * self.nodeWidth text_item = QGraphicsTextItem(text) text_item.moveBy(x-self.nodeWidth/4, y-self.nodeWidth/4) self.addItem(text_item) edge = QGraphicsLineItem(x, y, par_x, par_y) edge.setZValue(-1) self.addItem(edge) if node.left: self._constructTree(node.left, x-dx, y+dy, x, y, str(node.left.data), not squared, depth+1, 2*h_index) if node.right: self._constructTree(node.right, x+dx, y+dy, x, y, str(node.right.data), not squared, depth+1, 2*h_index+1)
def __init__(self, origin: QGraphicsRectItem, destination: QGraphicsRectItem, scene): super(GraphicLine, self).__init__() self.origin = origin self.destination = destination self.scene = scene # This flag confirms a legal connection self.is_valid = True # Get the four sides of the rects destination_lines = u.get_sides_of(self.destination.sceneBoundingRect()) origin_lines = u.get_sides_of(self.origin.sceneBoundingRect()) # Get the shortest edge between the two blocks self.setLine(self.gen_endpoints(origin_lines, destination_lines)) self.brush = QBrush(QColor(style.GREY_0)) self.pen = QPen(QColor(style.GREY_0)) self.pen.setWidth(4) self.pen.setCapStyle(Qt.RoundCap) self.pen.setJoinStyle(Qt.RoundJoin) self.setPen(self.pen) # Dimensions labels self.dim_label = QGraphicsTextItem() self.dim_label.setZValue(6) self.scene.addItem(self.dim_label) # Arrow head self.arrow_head = QGraphicsPolygonItem() self.arrow_head.setPen(self.pen) self.arrow_head.setBrush(self.brush) self.arrow_size = 15.0 self.draw_arrow()
class LabelItem(GraphicsItem): font_bold_italic = None def __init__(self, model_item: SimulatorProtocolLabel, parent=None): assert isinstance(model_item, SimulatorProtocolLabel) super().__init__(model_item=model_item, parent=parent) self.name = QGraphicsTextItem(self) self.name.setFont(GraphicsItem.font) def update_flags(self): if self.scene().mode == 1: self.set_flags(is_selectable=True, accept_hover_events=True) def update_numbering(self): pass def paint(self, painter, option, widget): painter.setBrush(constants.LABEL_COLORS[self.model_item.color_index]) painter.drawRect(self.boundingRect()) if self.scene().mode == 1: super().paint(painter, option, widget) def boundingRect(self): return self.childrenBoundingRect() def refresh(self): self.name.setPlainText(self.model_item.name)
def setPlainText(self, text): '''Sets the item's text to text. Argument(s): text (str): New text ''' QGraphicsTextItem.setPlainText(self, text) self.parentItem().updateShapeAndEdges()
def mousePressEvent(self, e): modifiers = QApplication.keyboardModifiers() if modifiers == Qt.ControlModifier: e.ignore() else: for item in self.scene().selectedItems(): item.setSelected(False) QGraphicsTextItem.mousePressEvent(self, e)
def keyPressEvent(self, event): '''Handle key pressed event. Argument(s): event (QKeyEvent): Key event ''' QGraphicsTextItem.keyPressEvent(self, event) self.parentItem().updateShapeAndEdges()
def initTitle(self): """Title is instanciated as `QGraphicsTextItem`""" # Draw the _title self.title_item = QGraphicsTextItem(self) self.title_item.node = self.node # add reference to the node self.title_item.setDefaultTextColor(self._title_color) self.title_item.setFont(self._title_font) self.title_item.setPos(self.title_horizontal_padding, 0)
def __init__(self, model_item: SimulatorRuleCondition, parent=None): assert isinstance(model_item, SimulatorRuleCondition) super().__init__(model_item=model_item, parent=parent) self.number.setFont(self.font_bold) self.text = QGraphicsTextItem(self) self.text.setPlainText(self.model_item.type.value) self.text.setFont(self.font_bold) self.desc = QGraphicsTextItem(self) self.desc.setFont(self.font)
def __init__(self, parent=None): QGraphicsView.__init__(self, parent) self.updateSecs = 0.5 # Border self.setLineWidth(0) self.setFrameShape(QtWidgets.QFrame.NoFrame) # Size sizePolicy = QSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred) sizePolicy.setHeightForWidth(True) self.setSizePolicy(sizePolicy) # No scrollbars self.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff) self.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff) # Scene self.scene = QGraphicsScene() self.setScene(self.scene) self.setBackgroundBrush(QColor("black")) # Text of clock self.textItem = QGraphicsTextItem() self.textItem.color = QColor(QColor("black")) self.textItem.setFont(QFont("Segoe UI", 80)) self.textItem.setDefaultTextColor(QColor("white")) self.textItem.setHtml("") self.textItem.setZValue(20) self.scene.addItem(self.textItem) # Start ticking self.start()
def __init__(self, model_item: SimulatorItem, parent=None): super().__init__(model_item=model_item, parent=parent) self.setFlag(QGraphicsTextItem.ItemIsPanel, True) self.text = QGraphicsTextItem(self) self.text.setFont(self.font)
def _setupTextItem(self): #Set up the text self.textItem=QGraphicsTextItem("",parent=self) textItem=self.textItem font=QFont() font.setPointSize(self._fontSize) textItem.setFont(font) textItem.setPos(QPointF(0,0)) #upper left corner relative to the father textItem.setDefaultTextColor(self._fontColor) if self._dbg: #another text item only for debug self.textItemBottom=QGraphicsTextItem("",parent=self) self.textItemBottom.setPos(QPointF(self.width,self.height)) self.textItemBottom.setDefaultTextColor(QColor(255, 255, 255)) self._updateTextBottom("shape " +str(self.shape))
def __init__(self, model_item: SimulatorMessage, parent=None): assert isinstance(model_item, SimulatorMessage) super().__init__(model_item=model_item, parent=parent) self.setFlag(QGraphicsItem.ItemIsPanel, True) self.arrow = MessageArrowItem(self) self.repeat_text = QGraphicsTextItem(self) self.repeat_text.setFont(self.font)
def __init__(self, parent=None, graphicView=None, graphicScene=None): super(ClassModel, self).__init__() self.set_default_data() self.className = QGraphicsTextItem(self) self.functionsItem = FunctionsContainerModel(self) self.className.setPlainText(self.defaultClassName) self.setFlag(self.ItemIsMovable) self.setFlag(self.ItemSendsGeometryChanges) self.functionsItem.setPos(0, self.__get_title_height()) self.attributesItem = FunctionsContainerModel(self) self.attributesItem.setPos(0, self.functionsItem.get_height())
def __init__(self, model_item: Participant, parent=None): super().__init__(parent) self.model_item = model_item self.text = QGraphicsTextItem(self) self.line = QGraphicsLineItem(self) self.line.setPen(QPen(Qt.darkGray, 1, Qt.DashLine, Qt.RoundCap, Qt.RoundJoin)) self.refresh()
def reshape(self): ''' Update the shape of the edge (redefined function) ''' path = QPainterPath() # If there is a starting point, draw a line to the first curve point if self.start_point: path.moveTo(self.source_connection.center) path.lineTo(self.bezier[0]) else: path.moveTo(self.source_connection.center) # Loop over the curve points: for group in self.bezier[1:]: path.cubicTo(*[point.center for point in group]) # If there is an ending point, draw a line to it if self.end_point: path.lineTo(self.end_connection.center) end_point = path.currentPosition() arrowhead = self.angle_arrow(path) path.lineTo(arrowhead[0]) path.moveTo(end_point) path.lineTo(arrowhead[1]) path.moveTo(end_point) try: # Add the transition label, if any (none for the START edge) font = QFont('arial', pointSize=8) metrics = QFontMetrics(font) label = self.edge.get('label', '') lines = label.split('\n') width = metrics.width(max(lines)) # longest line height = metrics.height() * len(lines) # lp is the position of the center of the text pos = self.mapFromScene(*self.edge['lp']) if not self.text_label: self.text_label = QGraphicsTextItem( self.edge.get('label', ''), parent=self) self.text_label.setX(pos.x() - width / 2) self.text_label.setY(pos.y() - height / 2) self.text_label.setFont(font) # Make horizontal center alignment, as dot does self.text_label.setTextWidth(self.text_label.boundingRect().width()) fmt = QTextBlockFormat() fmt.setAlignment(Qt.AlignHCenter) cursor = self.text_label.textCursor() cursor.select(QTextCursor.Document) cursor.mergeBlockFormat(fmt) cursor.clearSelection() self.text_label.setTextCursor(cursor) self.text_label.show() except KeyError: # no label pass self.setPath(path)
def set_functions_list(self, functionsList, prefix="", sufix=""): self.funtionsList = functionsList self.funtionsListItems = [] self.maxHeight = 0 tempHeight = 0 for element in functionsList: tempElement = QGraphicsTextItem(self) tempElement.setPlainText(prefix + element + sufix) tempElement.setPos(0, tempHeight) tempHeight += tempElement.document().size().height() if self.maxWidth < tempElement.document().size().width(): self.maxWidth = tempElement.document().size().width() self.funtionsListItems.append(tempElement) self.maxHeight = tempHeight
def define(self, cells): index = 0 cell_sum = 0 for y in range(self.height): for x in range(self.width): try: required_bridges = int(cells[y][x]) new_island = Island(index, x, y, required_bridges) self.islands.append(new_island) self.grid[y][x] = new_island text_item = QGraphicsTextItem(str(required_bridges)) text_item.setFont(self.font) text_item.setPos(30*x+5, 30*y-2) self.scene.addItem(text_item) cell_sum += required_bridges index += 1 except ValueError: pass if cell_sum % 2 == 0: self.total_required_bridges = int(cell_sum / 2) print("Found {} islands that require a total of {} bridges".format(index, self.total_required_bridges)) else: print("The grid is not valid!")
def textkeyPressEvent(self, event): """ Must intercept invalid input events. Make changes here """ a = event.key() text = event.text() if a in [Qt.Key_Space, Qt.Key_Tab]: return elif a in [Qt.Key_Return, Qt.Key_Enter]: self.inputMethodEventHandler(event) return # elif unicode(text).isalpha(): elif text.isalpha(): return else: return QGraphicsTextItem.keyPressEvent(self._label, event)
def updateIcon(self, id, uav_state, image_num=0): if uav_state.get_lon() == 0.0: #haven't received a Pose message yet return if id not in self.__plane_icons: #make the plane's label first label = QGraphicsTextItem(str(id), self.__plane_layer) label.setZValue(2) label.setDefaultTextColor(Qt.red) self.__plane_layer.addToGroup(label) label.show() self.__plane_labels[id] = label self.__plane_icons[id] = MapGraphicsIcon(id, label, self.__plane_layer) self.__plane_icons[id].centerIconAt(uav_state.get_lon(), -uav_state.get_lat()) self.__plane_icons[id].textureIcon(self.__plane_icon_pixmaps[image_num]) #plane icons need to be drawn on top of map tiles: self.__plane_icons[id].setZValue(1) self.__plane_layer.addToGroup(self.__plane_icons[id]) #key 0 = last update time self.__plane_icons[id].setData(0, 0) #refresh: #HACK: don't know why zooming works to refresh. Couldn't #get scene.invalidate() nor scene.update() to work self.onZoom(self.__current_detail_layer) #end if now = time.time() #if we don't have new pose data, then we don't update the plane icon if (self.__plane_icons[id].data(0) is None or self.__plane_icons[id].data(0) >= uav_state.get_last_pose_update()): return #place icon self.__plane_icons[id].centerIconAt(uav_state.get_lon(), -uav_state.get_lat()) #give correct heading: quat = uav_state.get_quat() heading = acs_math.yaw_from_quat(quat[0], quat[1], quat[2], quat[3]) self.__plane_icons[id].setHeading(heading) #set last update time self.__plane_icons[id].setData(0, now)
def keyPressEvent(self, event: QKeyEvent): """Must intercept invalid input events. Make changes here """ a = event.key() text = event.text() if a in [Qt.Key_Space, Qt.Key_Tab]: return elif a in [Qt.Key_Escape]: self.updateLabel() self.focusOut() return elif a in [Qt.Key_Return, Qt.Key_Enter]: self.inputMethodEvent(event) return elif text.isalpha(): return else: return QGraphicsTextItem.keyPressEvent(self, event)
def wait_for_first_image(self): if not self.display_real_image: return self.reset_zoom() self.display_real_image = False self.text_item = QGraphicsTextItem() self.text_item.setDefaultTextColor(QColor("white")) self.text_item.setPos(100, 70) self.text_item.setPlainText("In Trigger Mode. Waiting for first image...") bg = QPixmap(1280, 720) bg.fill(QColor("grey")) self.pix.setPixmap(bg) self.image_counter += 1 self.scene.addItem(self.text_item)
def __init__(self, scene, widthClkTextArea, heightClkTextArea, borders, updateSecs): self.masterScene = scene self.widthClkTextArea = widthClkTextArea self.heightClkTextArea = heightClkTextArea self.borders = borders self.updateSecs = updateSecs # Background self.textBkgd = QGraphicsRectItem(0, 0, self.widthClkTextArea, self.heightClkTextArea) self.textBkgd.setPos(self.borders[3], self.borders[0]) self.textBkgd.setBrush(QColor("light green")) self.textBkgd.setZValue(10) scene.addItem(self.textBkgd) # Text Item self.textItem = QGraphicsTextItem() self.textItem.setFont(QFont("Segoe UI", 80)) self.textItem.setDefaultTextColor(QColor("black")) self.textItem.setPos(QPointF(self.borders[3]+10,self.borders[0]+5)) self.textItem.setHtml("<B>Clock</B>") self.textItem.setZValue(20) self.textItem.setTextWidth(self.widthClkTextArea-20) scene.addItem(self.textItem)
def create_map_points(self): self.map_points_text_items = [] self.map_points_items = [] for map_point in self.map_data.map_points: color = QColor().fromRgb(map_point.r, map_point.g, map_point.b) rect = QGraphicsRectItem( QRectF( QPointF(map_point.x, map_point.y), QSizeF(5 / self.scale_ratio, 5 / self.scale_ratio) ) ) rect.setPen(QPen(Qt.black, 1 / self.scale_ratio)) rect.setBrush(color) self.map_points_items.append(rect) text = QGraphicsTextItem(map_point.text) text.setDefaultTextColor(color) text.setPos(map_point.x, map_point.y) text.setFont(QFont('Times New Roman', 8 / self.scale_ratio, 2)) self.map_points_text_items.append(text)
def __init__(self, pos, size, type_, parent = None, scene = None, areaBorder = 2, index = 0, textSize = 50): QGraphicsRectItem.__init__(self, 0, 0, size.width(), size.height(), parent) self.setPos(pos) self.newEvent = IsClicked() self.newEvent.area = self #self.setAcceptedMouseButtons(QtCore.Qt.NoButton) self.setFlags(QGraphicsItem.ItemIsMovable | QGraphicsItem.ItemIsFocusable | QGraphicsItem.ItemIsSelectable) ## set index label self.text = QGraphicsTextItem("%d" % index, self) self.setTextSize(textSize) ## TODO: How to create constants for the type? ## (such as constants in Qt) (enum?) self.kind = type_ pen = QPen(self.color, areaBorder, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin) self.setPen(pen)
def buildDiagram(self): """ Public method to build the class shapes of the package diagram. The algorithm is borrowed from Boa Constructor. """ self.allClasses = {} initlist = glob.glob(os.path.join(self.package, '__init__.*')) if len(initlist) == 0: ct = QGraphicsTextItem(None) self.scene.addItem(ct) ct.setHtml( self.tr("The directory <b>'{0}'</b> is not a package.") .format(self.package)) return modules = self.__buildModulesDict() if not modules: ct = QGraphicsTextItem(None) self.scene.addItem(ct) ct.setHtml( self.tr( "The package <b>'{0}'</b> does not contain any modules.") .format(self.package)) return # step 1: build all classes found in the modules classesFound = False for modName in list(modules.keys()): module = modules[modName] for cls in list(module.classes.keys()): classesFound = True self.__addLocalClass(cls, module.classes[cls], 0, 0) if not classesFound: ct = QGraphicsTextItem(None) self.scene.addItem(ct) ct.setHtml( self.tr( "The package <b>'{0}'</b> does not contain any classes.") .format(self.package)) return # step 2: build the class hierarchies routes = [] nodes = [] for modName in list(modules.keys()): module = modules[modName] todo = [module.createHierarchy()] while todo: hierarchy = todo[0] for className in list(hierarchy.keys()): cw = self.__getCurrentShape(className) if not cw and className.find('.') >= 0: cw = self.__getCurrentShape(className.split('.')[-1]) if cw: self.allClasses[className] = cw if cw and cw.noAttrs != self.noAttrs: cw = None if cw and not (cw.external and (className in module.classes or className in module.modules) ): if className not in nodes: nodes.append(className) else: if className in module.classes: # this is a local class (defined in this module) self.__addLocalClass( className, module.classes[className], 0, 0) elif className in module.modules: # this is a local module (defined in this module) self.__addLocalClass( className, module.modules[className], 0, 0, True) else: self.__addExternalClass(className, 0, 0) nodes.append(className) if hierarchy.get(className): todo.append(hierarchy.get(className)) children = list(hierarchy.get(className).keys()) for child in children: if (className, child) not in routes: routes.append((className, child)) del todo[0] # step 3: build the subpackages subpackages = self.__buildSubpackagesDict() for subpackage in sorted(subpackages.keys()): self.__addPackage(subpackage, subpackages[subpackage], 0, 0) nodes.append(subpackage) self.__arrangeClasses(nodes, routes[:]) self.__createAssociations(routes) self.umlView.autoAdjustSceneSize(limit=True)
class Edge(Connection): ''' B-spline/Bezier connection shape ''' def __init__(self, edge, graph): ''' Set generic parameters from Connection class ''' self.text_label = None super(Edge, self).__init__(edge['source'], edge['target']) self.edge = edge self.graph = graph # Set connection points as not visible, by default self.bezier_visible = False # Initialize control point coordinates self.bezier = [self.mapFromScene(*self.edge['spline'][0])] # Bezier control points (groups of three points): assert(len(self.edge['spline']) % 3 == 1) for i in xrange(1, len(self.edge['spline']), 3): self.bezier.append([Controlpoint( self.mapFromScene(*self.edge['spline'][i + j]), self) for j in range(3)]) # Create connection points at start and end of the edge self.source_connection = Connectionpoint( self.start_point or self.bezier[0], self, self.parent) self.parent.movable_points.append(self.source_connection) self.end_connection = Connectionpoint( self.end_point or self.bezier[-1], self, self.child) self.child.movable_points.append(self.end_connection) self.reshape() @property def start_point(self): ''' Compute connection origin - redefine in subclasses ''' # Start point is optional - graphviz decision return self.mapFromScene(*self.edge['start']) \ if self.edge.get('start') else None @property def end_point(self): ''' Compute connection end point - redefine in subclasses ''' return self.mapFromScene(*self.edge['end']) \ if self.edge.get('end') else None def bezier_set_visible(self, visible=True): ''' Display or hide the edge control points ''' self.bezier_visible = visible for group in self.bezier[1:]: for ctrl_point in group: if visible: ctrl_point.show() else: ctrl_point.hide() if visible: self.end_connection.show() self.source_connection.show() else: self.end_connection.hide() self.source_connection.hide() self.update() def mousePressEvent(self, event): ''' On a mouse click, display the control points ''' self.bezier_set_visible(True) # pylint: disable=R0914 def reshape(self): ''' Update the shape of the edge (redefined function) ''' path = QPainterPath() # If there is a starting point, draw a line to the first curve point if self.start_point: path.moveTo(self.source_connection.center) path.lineTo(self.bezier[0]) else: path.moveTo(self.source_connection.center) # Loop over the curve points: for group in self.bezier[1:]: path.cubicTo(*[point.center for point in group]) # If there is an ending point, draw a line to it if self.end_point: path.lineTo(self.end_connection.center) end_point = path.currentPosition() arrowhead = self.angle_arrow(path) path.lineTo(arrowhead[0]) path.moveTo(end_point) path.lineTo(arrowhead[1]) path.moveTo(end_point) try: # Add the transition label, if any (none for the START edge) font = QFont('arial', pointSize=8) metrics = QFontMetrics(font) label = self.edge.get('label', '') lines = label.split('\n') width = metrics.width(max(lines)) # longest line height = metrics.height() * len(lines) # lp is the position of the center of the text pos = self.mapFromScene(*self.edge['lp']) if not self.text_label: self.text_label = QGraphicsTextItem( self.edge.get('label', ''), parent=self) self.text_label.setX(pos.x() - width / 2) self.text_label.setY(pos.y() - height / 2) self.text_label.setFont(font) # Make horizontal center alignment, as dot does self.text_label.setTextWidth(self.text_label.boundingRect().width()) fmt = QTextBlockFormat() fmt.setAlignment(Qt.AlignHCenter) cursor = self.text_label.textCursor() cursor.select(QTextCursor.Document) cursor.mergeBlockFormat(fmt) cursor.clearSelection() self.text_label.setTextCursor(cursor) self.text_label.show() except KeyError: # no label pass self.setPath(path) def __str__(self): ''' user-friendly information about the edge coordinates ''' return('Edge between ' + self.edge['source'].name + ' and ' + self.edge['target'].name + str(self.edge['spline'][0])) def paint(self, painter, option, widget): ''' Apply anti-aliasing to Edge Connections ''' painter.setRenderHint(QPainter.Antialiasing, True) super(Edge, self).paint(painter, option, widget) # Draw lines between connection points, if visible if self.bezier_visible: painter.setPen( QPen(Qt.lightGray, 0, Qt.SolidLine)) painter.setBrush(Qt.NoBrush) points_flat = [point.center for sub1 in self.bezier[1:] for point in sub1] painter.drawPolyline([self.source_connection.center] + points_flat + [self.end_connection.center])
def focusOutEvent(self, event): self.inputMethodEvent(event) QGraphicsTextItem.focusOutEvent(self, event)
def event(self, event): if event.type() == QEvent.KeyPress and event.key() == Qt.Key_Tab: # print("tab pressed") return True return QGraphicsTextItem.event(self, event)
def __init__(self, label=""): # Parent constructor(s) QGraphicsTextItem.__init__(self, label)
class SimpleBlackbox(PyreeNode): """Blackbox node template with inputs on the left and outputs on the right""" # Here we define some information about the node author = "DrLuke" # Author of this node (only used for namespacing, never visible to users) modulename = "simplebb" # Internal name of the module, make this something distinguishable name = "Simple Blackbox" # Human-readable name placeable = False # Whether or not this node should be placeable from within the editor Category = ["Builtin"] # Nested categories this Node should be sorted in # Description, similar to python docstrings (Brief summary on first line followed by a long description) description = """This node is the base class for all nodes. It should never be placeable in the editor. However if you DO see this in the editor, something went wrong!""" # Class implementing this node. implementation = BaseImplementation def defineIO(self): raise NotImplementedError("This method must be implemented in derived class") def addInput(self, type, name, displayname): self.inputs.append([type, name, displayname]) def addOutput(self, type, name, displayname): self.outputs.append([type, name, displayname]) def addIO(self): """Add/Update IO""" self.inputs = [] self.outputs = [] self.defineIO() indexOffset = 2 verticalIoSpacing = 20 # Vertical Space between 2 IOs verticalIoStartOffset = (verticalIoSpacing * (max(len(self.inputs), len(self.outputs)) + indexOffset)) / 2 horizontalIoDistance = 10 maxInputWidth = 0 maxOutputWidth = 0 nodeTitleWidth = self.nodeTitle.boundingRect().width() titlePadding = 10 horizontalTextToIoDistance = 5 for ioDefinition in self.inputs: if ioDefinition[0] is not None: if ioDefinition[0] is execType: ioDefinition.append(ExecInput(ioDefinition[0], parent=self, name=ioDefinition[1], displaystr=ioDefinition[2])) else: ioDefinition.append(NodeInput(ioDefinition[0], parent=self, name=ioDefinition[1], displaystr=ioDefinition[2])) ioDefinition.append(QGraphicsTextItem(ioDefinition[2], ioDefinition[3])) maxInputWidth = max(maxInputWidth, ioDefinition[4].boundingRect().width()) ioDefinition[4].setPos(QPointF(horizontalTextToIoDistance, - ioDefinition[3].boundingRect().height() / 2 - ioDefinition[4].boundingRect().height() / 4)) self.IO[ioDefinition[1]] = ioDefinition[3] for ioDefinition in self.outputs: if ioDefinition[0] is not None: if ioDefinition[0] is execType: ioDefinition.append(ExecOutput(ioDefinition[0], parent=self, name=ioDefinition[1], displaystr=ioDefinition[2])) else: ioDefinition.append(NodeOutput(ioDefinition[0], parent=self, name=ioDefinition[1], displaystr=ioDefinition[2])) ioDefinition.append(QGraphicsTextItem(ioDefinition[2], ioDefinition[3])) maxOutputWidth = max(maxInputWidth, ioDefinition[4].boundingRect().width()) ioDefinition[4].setPos(QPointF(- horizontalTextToIoDistance - ioDefinition[4].boundingRect().width(), - ioDefinition[3].boundingRect().height() / 2 - ioDefinition[4].boundingRect().height() / 4)) self.IO[ioDefinition[1]] = ioDefinition[3] width = max(maxInputWidth + maxOutputWidth + horizontalIoDistance, nodeTitleWidth + titlePadding) height = verticalIoSpacing * (max(len(self.inputs), len(self.outputs)) + indexOffset - 1) self.mainRect.setRect(QRectF(-width/2, -height/2, width, height)) for ioDefinition in self.inputs: if ioDefinition[0] is not None: ioDefinition[3].setPos(QPointF(-width/2, - verticalIoStartOffset + (self.inputs.index(ioDefinition) + indexOffset) * verticalIoSpacing)) for ioDefinition in self.outputs: if ioDefinition[0] is not None: ioDefinition[3].setPos(QPointF(width / 2, - verticalIoStartOffset + (self.outputs.index(ioDefinition) + indexOffset) * verticalIoSpacing)) self.nodeTitle.setPos(QPointF(- nodeTitleWidth / 2, -height / 2)) def boundingRect(self): return self.mainRect.rect() def addGraphicsItems(self): self.mainRect = QGraphicsRectItem(QRectF(-15, -15, 30, 30), self) self.nodeTitle = QGraphicsTextItem(type(self).name, self) titleFont = QFont() titleFont.setBold(True) self.nodeTitle.setFont(titleFont) self.selectedChanged(self.isSelected()) def selectedChanged(self, state): if state: self.mainRect.setPen(QPen(Qt.red)) else: self.mainRect.setPen(QPen(Qt.black)) def serialize(self): return None def deserialize(self, data): pass