def slot_fill_combobox(self): if self.currentPalette is None: pass palette = self.currentPalette self.colorComboBox.clear() self.colorList = list() for i in range(palette.colorsCountTotal()): entry = palette.colorSetEntryByIndex(i) color = palette.colorForEntry(entry).colorForCanvas(self.canvas()) colorSquare = QPixmap(12, 12) if entry.spotColor() is True: img = colorSquare.toImage() circlePainter = QPainter() img.fill(self.colorComboBox.palette().color(QPalette.Base)) circlePainter.begin(img) brush = QBrush(Qt.SolidPattern) brush.setColor(color) circlePainter.setBrush(brush) circlePainter.pen().setWidth(0) circlePainter.drawEllipse(0, 0, 11, 11) circlePainter.end() colorSquare = QPixmap.fromImage(img) else: colorSquare.fill(color) name = entry.name() if len(entry.id()) > 0: name = entry.id() + " - " + entry.name() self.colorList.append(name) self.colorComboBox.addItem(QIcon(colorSquare), name) self.colorComboBox.setEditable(True) self.colorComboBox.setInsertPolicy(QComboBox.NoInsert) self.colorComboBox.completer().setCompletionMode( QCompleter.PopupCompletion) self.colorComboBox.completer().setCaseSensitivity(False) self.colorComboBox.completer().setFilterMode(Qt.MatchContains)
def drow(self, pos, state, drawLine): painter = QPainter(self.label.pixmap()) if state: painter.setBrush(QBrush(QColor(255, 0, 0), Qt.SolidPattern)) painter.setPen(QColor(255, 0, 0)) else: brush = QBrush() brush.setTexture(self.label.orginalImage) painter.setBrush(brush) painter.setPen(QColor(Qt.transparent)) painter.pen().setWidth(self.label.brushSize) painter.drawEllipse(pos.x() - self.label.brushSize / 2, pos.y() - self.label.brushSize / 2, self.label.brushSize, self.label.brushSize) if drawLine: painter.drawLine(pos, self.label.lastPos) painter2 = QPainter(self.label.selctedRegionImage) if state: painter2.setBrush(QBrush(QColor(255, 0, 0), Qt.SolidPattern)) painter2.setPen(QColor(255, 0, 0)) else: brush = QBrush() brush.setTexture(QPixmap(self.label.orginalImage.size())) painter2.setBrush(brush) painter2.setPen(QColor(Qt.transparent)) painter2.pen().setWidth(self.label.brushSize) painter2.drawEllipse(pos.x() - self.label.brushSize / 2, pos.y() - self.label.brushSize / 2, self.label.brushSize, self.label.brushSize) if drawLine: painter2.drawLine(pos, self.label.lastPos) self.label.update()
def paintEvent(self, event): super().paintEvent(event) painter = QPainter(self) width = self.width() height = self.height() bgColor = self.palette().color(self.backgroundRole()) painter.fillRect(0, 0, width, height, bgColor) hourStep = height / 24 pen = painter.pen() pen.setColor(QColor("black")) painter.setPen(pen) painter.drawText(0, 0, width - 6, hourStep, Qt.TextSingleLine | Qt.AlignTop | Qt.AlignRight, "0") for h in range(0, 24): hourHeight = hourStep * h text = str(h) pen = painter.pen() pen.setColor(QColor("gray")) painter.setPen(pen) painter.drawLine(0, hourHeight, width, hourHeight) pen = painter.pen() pen.setColor(QColor("black")) painter.setPen(pen) painter.drawText(0, hourHeight, width - 6, hourStep, Qt.TextSingleLine | Qt.AlignTop | Qt.AlignRight, text)
def fillSizesModel(self): # First we empty the old model. We might wanna use this function in the future to fill it with the brushmask of the selected brush, but there's currently no API for recognising changes in the current brush nor is there a way to get its brushmask. self.brushSizeModel.clear() for s in range(len(self.sizesList)): # we're gonna itterate over our list, and make a new item for each entry. # We need to disable a bunch of stuff to make sure people won't do funny things to our entries. item = QStandardItem() item.setCheckable(False) item.setEditable(False) item.setDragEnabled(False) item.setText(str(self.sizesList[s]) + " px") # And from here on we'll make an icon. brushImage = QPixmap(64, 64) img = QImage(64, 64, QImage.Format_RGBA8888) circlePainter = QPainter() img.fill(Qt.transparent) circlePainter.begin(img) brush = QBrush(Qt.SolidPattern) brush.setColor(self.brushSizeTableView.palette().color( QPalette.Text)) circlePainter.setBrush(brush) circlePainter.pen().setWidth(0) brushSize = max(min((self.sizesList[s] / 500) * 100, 64), 1) brushSize = brushSize * 0.5 circlePainter.drawEllipse(QPointF(32, 32), brushSize, brushSize) circlePainter.end() brushImage = QPixmap.fromImage(img) # now we're done with drawing the icon, so we set it on the item. item.setIcon(QIcon(brushImage)) self.brushSizeModel.appendRow(item) self.brushSizeTableView.setModel(self.brushSizeModel)
def paintEvent(self, event): painter = QPainter() painter.begin(self) painter.pen().setWidth(1) ellipse_width = 5 offset = ellipse_width / 2.0 for (x, y) in self.points: painter.drawEllipse(x, y, ellipse_width, ellipse_width) painter.save() painter.setPen(QColor("red")) for i in range(len(self.hull)): start = self.hull[i] end = self.hull[(i + 1) % len(self.hull)] assert start in self.points assert end in self.points start_x = start[0] + offset start_y = start[1] + offset end_x = end[0] + offset end_y = end[1] + offset painter.drawLine(start_x, start_y, end_x, end_y) painter.restore() painter.end()
def fillOpacityModel(self): self.brushOpacityModel.clear() self.brushFlowModel.clear() for s in range(len(self.opacityList)): # we're gonna itterate over our list, and make a new item for each entry. item = QStandardItem() item.setCheckable(False) item.setEditable(False) item.setDragEnabled(False) item.setText(str(self.opacityList[s]) + " %") brushImage = QPixmap(64, 64) img = QImage(64, 64, QImage.Format_RGBA8888) circlePainter = QPainter() img.fill(Qt.transparent) circlePainter.begin(img) brush = QBrush(Qt.SolidPattern) brush.setColor(self.brushSizeTableView.palette().color( QPalette.Text)) circlePainter.setBrush(brush) circlePainter.pen().setWidth(0) circlePainter.setOpacity(self.opacityList[s] / 100) circlePainter.drawEllipse(QPointF(32, 32), 32, 32) circlePainter.end() brushImage = QPixmap.fromImage(img) item.setIcon(QIcon(brushImage)) # the flow and opacity models will use virtually the same items, but Qt would like us to make sure we understand # these are not really the same items, so hence the clone. itemFlow = item.clone() self.brushOpacityModel.appendRow(item) self.brushFlowModel.appendRow(itemFlow) self.brushOpacityTableView.setModel(self.brushOpacityModel) self.brushFlowTableView.setModel(self.brushFlowModel)
def drawBackground(self, painter: QPainter, rect: QRectF): if self.draw_grid and len(self.frequencies) > 0: painter.setPen(QPen(painter.pen().color(), 0)) parent_width = self.parent().width() if hasattr( self.parent(), "width") else 750 view_rect = self.parent().view_rect() if hasattr( self.parent(), "view_rect") else rect font_width = self.font_metrics.width( Formatter.big_value_with_suffix(self.center_freq) + " ") x_grid_size = int(view_rect.width() / parent_width * font_width) # x_grid_size = int(0.1 * view_rect.width()) if 0.1 * view_rect.width() > 1 else 1 y_grid_size = 1 x_mid = np.where(self.frequencies == 0)[0] x_mid = int(x_mid[0]) if len(x_mid) > 0 else 0 left = int(rect.left()) - (int(rect.left()) % x_grid_size) left = left if left > 0 else 0 top = rect.top() - (rect.top() % y_grid_size) bottom = rect.bottom() - (rect.bottom() % y_grid_size) right_border = int( rect.right()) if rect.right() < len(self.frequencies) else len( self.frequencies) scale_x, scale_y = util.calc_x_y_scale(rect, self.parent()) fh = self.font_metrics.height() x_range = list(range(x_mid, left, -x_grid_size)) + list( range(x_mid, right_border, x_grid_size)) lines = [QLineF(x, rect.top(), x, bottom-fh*scale_y) for x in x_range] \ + [QLineF(rect.left(), y, rect.right(), y) for y in np.arange(top, bottom, y_grid_size)] pen = painter.pen() pen.setStyle(Qt.DotLine) painter.setPen(pen) painter.drawLines(lines) painter.scale(scale_x, scale_y) counter = -1 # Counter for Label for every second line for x in x_range: freq = self.frequencies[x] counter += 1 if freq == 0: counter = 0 if freq != 0 and (counter % 2 != 0): # Label for every second line continue value = Formatter.big_value_with_suffix( self.center_freq + freq, 2) font_width = self.font_metrics.width(value) painter.drawText( QPointF(x / scale_x - font_width / 2, bottom / scale_y), value)
def paintEvent(self, e): width = height = 18 painter = QPainter(self) painter.save() painter.setRenderHints(QPainter.Antialiasing) painter.translate((self.width() - width) // 2, (self.height() - height) // 2) line_height = 1.3 line_margin = (height - 3 * line_height) / 3 h1 = line_margin h2 = h1 + line_margin + line_height h3 = h2 + line_margin + line_height pen = painter.pen() pen.setColor(QColor("#6F6F6F")) pen.setWidthF(line_height) painter.setPen(pen) painter.setBrush(pen.color()) # Draw triangle and first line triangle_side_length_half = line_margin * 0.6 triangle_height = triangle_side_length_half * 1.7 triangle = QPolygonF([ QPointF(0, h1 - triangle_side_length_half), QPointF(triangle_height, h1), QPointF(0, h1 + triangle_side_length_half) ]) painter.drawPolygon(triangle) painter.drawLine( QPointF(triangle_height + triangle_side_length_half, h1), QPointF(width, h1)) # Draw second line painter.drawLine(QPointF(0, h2), QPointF(width, h2)) # Draw third line, show FM text if needed if self._app.playlist.mode is PlaylistMode.fm: painter.drawLine(QPointF(0, h3), QPointF(width // 2, h3)) painter.pen() pen.setColor(QColor(SOLARIZED_COLORS['blue'])) painter.setPen(pen) font = painter.font() rect_h_half = line_margin // 2 font.setPixelSize(int(rect_h_half * 2)) painter.setFont(font) rect = QRectF(width // 2 + rect_h_half, h3 - rect_h_half, width // 2 - rect_h_half, rect_h_half * 2) painter.drawText(rect, "FM", QTextOption(Qt.AlignCenter)) else: painter.drawLine(QPointF(0, h3), QPointF(width, h3)) painter.restore()
def set_boundary(self, painter: QPainter, color: QColor = None, line_width: float = None, style: QStyle = None): pen_line_width = line_width if line_width is not None \ else painter.pen().width() pen_style = style if style is not None else painter.pen().style() if color is not None: pen = QPen(color, pen_line_width, pen_style) else: pen = QPen(Qt.NoPen) painter.setPen(pen)
def paintEvent(self, event): painter = QPainter() painter.begin(self) painter.pen().setWidth(1) for i in range(self.dimension * self.dimension): y = int(i / self.dimension) x = int(i % self.dimension) pos_x = x * self.cell_width pos_y = y * self.cell_width pos_x += 1 pos_y += 1 path_index = self.path.index(i) if i in self.path else None fill = 'white' if self.start == (x, y): fill = 'green' elif self.end == (x, y): fill = 'red' elif path_index: fill = 'blue' vertex = self.graph[i] neighbours = ( ((-1, 0), (pos_x, pos_y, pos_x, pos_y + self.cell_width)), ((0, 1), (pos_x, pos_y + self.cell_width, pos_x + self.cell_width, pos_y + self.cell_width)), ((1, 0), (pos_x + self.cell_width, pos_y + self.cell_width, pos_x + self.cell_width, pos_y)), ((0, -1), (pos_x + self.cell_width, pos_y, pos_x, pos_y)), ) for ((i_x, i_y), bbox) in neighbours: if self.linearize((x + i_x, y + i_y)) not in vertex: painter.drawLine(*bbox) offset = 1 painter.fillRect(pos_x + offset, pos_y + offset, self.cell_width - offset, self.cell_width - offset, QColor(fill)) if path_index is not None: painter.save() painter.setPen(QColor('white')) painter.drawText(pos_x, pos_y, self.cell_width, self.cell_width, Qt.AlignHCenter | Qt.AlignVCenter, str(path_index)) painter.restore() painter.end()
def _drawBorder(self, painter: QPainter): """отрисовка границы области графика""" logger.debug(self._drawBorder.__doc__) pen = painter.pen() painter.setPen(self._style['grid']['border']) painter.drawRect(QRectF(0, 0, self.getDrawArea().width(), self.getDrawArea().height())) painter.setPen(pen)
def paintEvent(self, a0: QtGui.QPaintEvent): painter = QPainter(self) pen = painter.pen() pen.setColor(Qt.black) pen.setWidth(2) painter.setPen(pen) board_x, board_y, board_width, board_height = self.boardSize for i in range(8): lx = board_x + i * 80 painter.drawLine(lx, board_y, lx, board_y + board_height) for j in range(7): ly = board_y + j * 80 painter.drawLine(board_x, ly, board_x + board_width, ly) brush = painter.brush() brush.setColor(Qt.green) brush.setStyle(Qt.SolidPattern) painter.setBrush(brush) if 0 <= self.mousePos <= 6: tr_y = board_y - 20 tr_x = board_x + self.mousePos * 80 + 40 painter.drawPolygon(QPoint(tr_x - 20, tr_y - 20), QPoint(tr_x, tr_y), QPoint(tr_x + 20, tr_y - 20)) for col in range(7): for row in range(5, -1, -1): piece = self.controller.gameModel[row][col] if piece == -1: break if piece == 0: brush.setColor(QColor("#db0000")) else: brush.setColor(QColor("#00468b")) painter.setBrush(brush) painter.drawEllipse(QPoint(board_x + col * 80 + 40, board_y + row * 80 + 40), 35, 35)
def generateCode(article, week, lot): #function returns QPicture object containing DataMatrix code with given article, week, lot toBeEncoded = 'S/N %s, Lot %s, Date %s' % (article, lot, week) bar = toBeEncoded.encode('utf-8') encoded_bar = dmtx.encode(bar) img = Image.frombytes('RGB', (encoded_bar.width, encoded_bar.height), encoded_bar.pixels) img = img.resize(qr_size) qimg = ImageQt(img) picture = QPicture() painter = QPainter() painter.begin(picture) if frame_options['pen-color'] != Qt.Qt.white: painter.setBrush(QBrush(Qt.Qt.white)) painter.setFont(QFont(font['family'], font['size'], font['weight'])) if frame_options['pen-color'] != Qt.Qt.white: old_pen = painter.pen() painter.setPen( QPen(frame_options['pen-color'], frame_options['pen-width'])) painter.drawRoundedRect(0, 0, *label_size, frame_options['radius'], frame_options['radius']) painter.setPen(old_pen) painter.drawText(*item_positions['article'], "S/N " + article) painter.drawText(*item_positions['week'], "Date " + week) painter.drawText(*item_positions['lot'], "Lot " + lot) painter.drawImage(*item_positions['code'], qimg) painter.end() return picture
def mouseMoveEvent(self, e): # ignore event if mouse button is not held if self.last_x is None: self.last_x = e.x() self.last_y = e.y() return painter = QPainter(self.pixmap()) p = painter.pen() p.setWidth(4) p.setColor(self.penColor) painter.setPen(p) painter.drawLine(self.last_x, self.last_y, e.x(), e.y()) # start x, start y, end x, end y, color in hex# self.canvasChangedSignal.emit( [self.last_x, self.last_y, e.x(), e.y(), self.penColor.name()]) painter.end() self.update() # update origin for next time self.last_x = e.x() self.last_y = e.y()
def paintGame(painter: QPainter): global board painter.fillRect(0, 0, 700, 700, Qt.white) # ERSCHAFFT FREIEN PLATZ OBEN painter.fillRect(0, 100, 700, 600, Qt.blue) # FUELLT RECHTECK AUS pen = painter.pen() # STIFT WIRD ERZEUGT pen.setWidth(3) painter.setPen(pen) # PEN WIRD ANGESETZ # We offset the rows by one to leave space to "throw the chips" for y in range(2, rows): y1 = y * 100 x1 = 0 x2 = 700 painter.drawLine(x1, y1, x2, y1) # HORIZONTALE LINIEN for x in range(1, cols): y1 = 100 y2 = 700 x1 = x * 100 painter.drawLine(x1, y1, x1, y2) # VERTIKALE LINIEN font = painter.font() font.setPixelSize(80) # PIXELGROESSE VON FONT painter.setFont(font) for y in range(rows): # BERECHNET STELLE IM FELD AUF X EBENE for x in range(cols): # BERECHNET STELLE IM FELD AUF Y EBENE if board[x][y] != '_': painter.drawText(x * 100, y * 100, 100, 100, Qt.AlignCenter, board[x][y])
def _drawLabels(self, painter: QPainter): """отображение подписей на осях""" f_m = QFontMetricsF(self._style['grid']['font']) pen = painter.pen() text = 'Расход, м³/сутки' offset_x = self._margins[0] + self.getDrawArea().width() / 2 offset_x -= f_m.width(text) / 2 offset_y = self.height() - self._margins[3] + f_m.height() offset_y += 20 painter.setPen(self._style['grid']['border']) painter.drawText(QPointF(offset_x, offset_y), text) text = 'Напор, м' offset_x = 0 - f_m.height() - 5 self._drawLabel(painter, f_m, offset_x, text) text = 'Мощность, кВт' offset_x = self._margins[0] + self.getDrawArea().width() + 10 painter.setPen(self._charts['etl_pwr'].pen) self._drawLabel(painter, f_m, offset_x, text) text = 'КПД, %' offset_x = self._margins[0] + self.getDrawArea().width() + \ self._grid_divs['y1'].width + 40 painter.setPen(self._charts['etl_eff'].pen) self._drawLabel(painter, f_m, offset_x, text) painter.setPen(pen)
def paintEvent(self, event): p = QPainter(self) p.setRenderHint(QPainter.Antialiasing, True) p.save() side = self.height() p.scale(side / 100.0, side / 100.0) width = 100 * self.width() height = 100 * self.height() width = 100.0 * self.width() / self.height() height = 100.0 pen = QPen(p.pen()) pen.setColor(QColor(32, 32, 32)) pen.setWidthF(6.0) p.setPen(pen) p.setBrush(Qt.black) p.drawRoundedRect(3, 3, width - 6, height - 6, 7, (7 * width) / height) w = (width - 2 * self.Y_OFFSET) / self.m_digits x = (self.m_digits - 1) * w h = height - 2 * self.Y_OFFSET c = self.m_value r = 0 for i in range(self.m_digits): r = c % 10 c = c // 10 rect = QRectF(x + self.X_OFFSET, self.Y_OFFSET, w, h) self.m_svg.render(p, "d{}".format(r), rect) x -= w p.restore()
def paintEvent(self, event): print('hujFrame PaintEvent()', event.rect()) painter = QPainter() rect = painter.viewport() print('hujFrame painter.viewport()', event.rect()) painter.begin(self) painter.save() font = painter.font() font.setPixelSize(56) painter.setFont(font) # painter.translate(100, 100) rectangle = QRect(160, 160, 100, 50) boundingRect = painter.drawText(rectangle, 0, self.tr("Hello")) pen = painter.pen() pen.setStyle(Qt.DotLine) painter.setPen(pen) painter.drawRect( boundingRect.adjusted(0, 0, -pen.width(), -pen.width())) pen.setStyle(Qt.DashLine) painter.setPen(pen) painter.drawRect(rectangle.adjusted(0, 0, -pen.width(), -pen.width())) painter.restore() painter.end() del painter super(hujFrame, self).paintEvent(event)
def drawAxes(self, painter: QPainter): """ Метод для рисования осей с подписями :param: painter объект QPainter для рисования """ pen = painter.pen() # print(dir(pen)) painter.setPen(Qt.black) painter.drawLine(0, self.o_y, self.width, self.o_y) painter.drawLine(self.o_x, 0, self.o_x, self.height) for dx in range(0, self.width, DrawConst.scaleX): if dx == self.o_x: continue painter.drawEllipse(QPoint(dx, self.o_y), 1, 1) qp: QPoint = QPoint(dx, self.o_y) painter.drawText(dx - 2, self.o_y - 2, str(int(self.to_decart(qp).x()))) for dy in range(0, self.height, DrawConst.scaleY): if dy == self.o_y: continue painter.drawEllipse(QPoint(self.o_x, dy), 1, 1) qp: QPoint = QPoint(self.o_x, dy) painter.drawText(self.o_x + 4, dy + 4, str(int(self.to_decart(qp).y()))) painter.setPen(pen)
def rasterSurfaceRender(self, painter: QPainter): if self._editingPolygon is None: return pointColor = self.pointColor lineColor = self.lineColor pen: QPen = painter.pen() pen.setColor(lineColor) pen.setWidth(1) painter.setPen(pen) height = self.rasterSurface.height() ln = self._editingPolygon.length if ln > 0: prev = None for p in self._editingPolygon.points_iter(): if prev is None: prev = p painter.fillRect(p.x - 5, height - p.y - 5, 10, 10, pointColor) else: painter.fillRect(p.x - 5, height - p.y - 5, 10, 10, pointColor) painter.drawLine(prev.x, height - prev.y, p.x, height - p.y) prev = p p = self._cursorPos # Qt's QPoint painter.fillRect(p.x() - 5, p.y() - 5, 10, 10, pointColor) painter.drawLine(prev.x, height - prev.y, p.x(), p.y()) else: p = self._cursorPos # Qt's QPoint painter.fillRect(p.x() - 5, p.y() - 5, 10, 10, pointColor)
def draw_tags(self, painter: QPainter, from_ind: int, to_ind: int) -> None: """ Draw the tags between two particular indices. """ for ind in range(from_ind, to_ind): i_r = self.tags[ind].rect text_pos = i_r.topLeft() + QPointF( TAG_TEXT_HORIZONTAL_PADDING, self.fontMetrics().ascent() + ((i_r.height() - self.fontMetrics().height()) // 2), ) # draw rect painter.setPen(EDIT_TAG_BORDER_COLOR) path = QPainterPath() path.addRoundedRect(i_r, TAG_HEIGHT // 2, TAG_HEIGHT // 2) painter.fillPath(path, EDIT_TAG_BACKGROUND_COLOR) painter.drawPath(path) # draw text painter.setPen(EDIT_TAG_TEXT_COLOR) painter.drawText(text_pos, self.tags[ind].text) # calc cross rect i_cross_r = TagsLineEdit.compute_cross_rect(i_r) pen = painter.pen() pen.setWidth(2) painter.setPen(pen) painter.drawLine( QLineF(i_cross_r.topLeft(), i_cross_r.bottomRight())) painter.drawLine( QLineF(i_cross_r.bottomLeft(), i_cross_r.topRight()))
def getFileIcon(self): # _text = Path(self.alt).name _suffix = Path(self.alt).suffix.upper() _suffix = _suffix[1:] if _suffix else "(Unknown)" _pixmap = QPixmap(120, 120) _pixmap.fill(QColor(0, 0, 0, 0)) _painter = QPainter(_pixmap) _painter.setRenderHints(QPainter.Antialiasing | QPainter.TextAntialiasing) # draw rounded rect _pen = _painter.pen() _pen.setWidth(2) _painter.setPen(_pen) _painter.drawRoundedRect(QRect(1, 1, 118, 118), 15, 15) # draw suffix text _rect = QRect(8, 10, 108, 35) #100*25 _painter.setPen(QPen(QColor("#0f59a4"))) _painter.setFont(CFG.FONT_ICON_SUFFIX('MFHistoryItem')) _painter.drawText(_rect, Qt.AlignHCenter | Qt.TextSingleLine, _suffix) _painter.setPen(_pen) # draw splitter _painter.drawLine(1, 40, 118, 40) # draw suffix text _rect = QRect(8, 45, 108, 110) #100*65 _painter.setFont(CFG.FONT_ICON_NAME('MFHistoryItem')) _fm = QFontMetrics(_painter.font()) # _elided_text = _fm.elidedText(_text, Qt.ElideMiddle, _rect.width(), Qt.TextWrapAnywhere) _painter.drawText(_rect, Qt.AlignHCenter | Qt.TextWrapAnywhere, _text) del _painter return _pixmap
def paintEvent(self, event): p = QPainter(self) if self.scrollEnabled: self.buffer.fill(qRgba(0, 0, 0, 0)) pb = QPainter(self.buffer) pb.setPen(p.pen()) pb.setFont(p.font()) x = min(-self.scrollPos, 0) + self.leftMargin while x < self.width(): pb.drawStaticText( QPointF(x, (self.height() - self.wholeTextSize.height()) / 2) + QPoint(2, 2), self.staticText) x += self.wholeTextSize.width() #Apply Alpha Channel pb.setCompositionMode(QPainter.CompositionMode_DestinationIn) pb.setClipRect(self.width() - 15, 0, 15, self.height()) pb.drawImage(0, 0, self.alphaChannel) pb.setClipRect(0, 0, 15, self.height()) #initial situation: don't apply alpha channel in the left half of the image at all; apply it more and more until scrollPos gets positive if self.scrollPos < 0: pb.setOpacity((max(-8, self.scrollPos) + 8) / 8.0) pb.drawImage(0, 0, self.alphaChannel) p.drawImage(0, 0, self.buffer) else: x = (self.width() - self.wholeTextSize.width()) / 2 y = (self.height() - self.wholeTextSize.height()) / 2 p.drawStaticText(QPointF(x, y), self.staticText)
def paintEvent(self, event): super().paintEvent(event) painter = QPainter(self) width = self.width() height = self.height() path = QPainterPath() path.addRoundedRect(2, 0, width - 4, height, 5, 5) # taskBgColor = monthcalendar.get_task_bgcolor( self.task ) selected = self.isSelected() taskBgColor = get_task_bgcolor(self.task, selected) painter.fillPath(path, taskBgColor) pathPen = QPen(QColor("black")) pathPen.setWidth(2) painter.strokePath(path, pathPen) pen = painter.pen() pen.setColor(QColor("black")) painter.setPen(pen) if height < 32: painter.drawText( 6, 0, width - 12, height, Qt.TextSingleLine | Qt.AlignVCenter | Qt.AlignLeft, self.task.title) else: painter.drawText( 6, 0, width - 12, 32, Qt.TextSingleLine | Qt.AlignVCenter | Qt.AlignLeft, self.task.title)
def paint_circle(self, painter: QtGui.QPainter, option: 'QStyleOptionGraphicsItem', widget): pen = painter.pen() pen.setColor(self.color) pen.setWidth(self.width) painter.setPen(pen) painter.drawEllipse(0, 0, self.radius * 2, self.radius * 2)
def rasterSurfaceRender(self, painter: QPainter): if self._editingPolygon is None: return pointColor = self.pointColor activePointColor = self.activePointColor lineColor = self.lineColor pen: QPen = painter.pen() pen.setColor(lineColor) pen.setWidth(1) painter.setPen(pen) height = self.rasterSurface.height() for p in self._editingPolygon.points: painter.fillRect( p.x - 5, height - p.y - 5, 10, 10, activePointColor if p is self._highlightedPoint else pointColor ) for l in self._editingPolygon.lines_iter(): painter.drawLine( l.start.x, height - l.start.y, l.end.x, height - l.end.y )
def drawCanvas(self, painter: QPainter): pen = painter.pen() painter.setPen(Qt.gray) if DrawConst.grid: self.drawGrid(painter) if DrawConst.axes: self.drawAxes(painter) painter.setPen(pen)
def paintEvent(self, e): p = QPainter(self) p.setPen(p.pen()) p.setFont(p.font()) p.drawText( QPointF(self.x, (self.height() + self.fontMetrics().height()) / 2) + QPoint(2, -4), self.text_)
def lineDraw(self,pos1,pos2): painter = QPainter(self.pixmap()) p = painter.pen() p.setWidth(3) p.setColor(self.pen_color) painter.setPen(p) painter.drawLine(pos1, pos2) painter.end() self.update()
def draw_selected_point(self, drawer): pen = QPainter.pen(drawer) pen.setWidth(3.5) pen.setBrush(Qt.red) pen.setCapStyle(Qt.RoundCap) drawer.setPen(pen) drawer.setBrush(Qt.transparent) drawer.drawRect(self.firstPos[0] * self.scale, self.firstPos[1] * self.scale, self.scale, self.scale)
def drawBackground(self, painter: QPainter, rect: QRectF): # freqs = np.fft.fftfreq(len(w), 1 / self.sample_rate) if self.draw_grid and len(self.frequencies) > 0: painter.setPen(QPen(painter.pen().color(), Qt.FlatCap)) parent_width = self.parent().width() if hasattr(self.parent(), "width") else 750 view_rect = self.parent().view_rect() if hasattr(self.parent(), "view_rect") else rect font_width = self.font_metrics.width(Formatter.big_value_with_suffix(self.center_freq) + " ") x_grid_size = int(view_rect.width() / parent_width * font_width) # x_grid_size = int(0.1 * view_rect.width()) if 0.1 * view_rect.width() > 1 else 1 y_grid_size = view_rect.height() / parent_width * font_width x_mid = np.where(self.frequencies == 0)[0] x_mid = int(x_mid[0]) if len(x_mid) > 0 else 0 left = int(rect.left()) - (int(rect.left()) % x_grid_size) left = left if left > 0 else 0 top = rect.top() - (rect.top() % y_grid_size) bottom = rect.bottom() - (rect.bottom() % y_grid_size) right_border = int(rect.right()) if rect.right() < len(self.frequencies) else len(self.frequencies) x_range = list(range(x_mid, left, -x_grid_size)) + list(range(x_mid, right_border, x_grid_size)) lines = [QLineF(x, rect.top(), x, bottom) for x in x_range] \ + [QLineF(rect.left(), y, rect.right(), y) for y in np.arange(top, bottom, y_grid_size)] painter.drawLines(lines) scale_x = view_rect.width() / parent_width scale_y = view_rect.height() / parent_width painter.scale(scale_x, scale_y) font_height = self.font_metrics.height() counter = -1 # Counter for Label for every second line for x in x_range: freq = self.frequencies[x] counter += 1 if freq != 0 and (counter % 2 != 0): # Label for every second line continue if freq != 0: prefix = "+" if freq > 0 else "" value = prefix+Formatter.big_value_with_suffix(freq, 2) else: counter = 0 value = Formatter.big_value_with_suffix(self.center_freq) font_width = self.font_metrics.width(value) painter.drawText(x / scale_x - font_width / 2, bottom / scale_y + font_height, value)
def paintEvent(self, event): # From Peter, thanks ! # http://thecodeinn.blogspot.fr/2015/02/customizing-qdials-in-qt-part-1.html painter = QPainter(self) # So that we can use the background color painter.setBackgroundMode(1) # Smooth out the circle painter.setRenderHint(QPainter.Antialiasing) # Use background color painter.setBrush(painter.background()) # Store color from stylesheet, pen will be overriden pointColor = QColor(painter.pen().color()) # No border painter.setPen(QPen(Qt.NoPen)) # Draw first circle painter.drawEllipse(0, 0, self.width(), self.height()) # Reset color to pointColor from stylesheet painter.setBrush(QBrush(pointColor)) # Get ratio between current value and maximum to calculate angle ratio = self.value() / self.maximum() # The maximum amount of degrees is 270, offset by 225 angle = ratio * self._degree270 - self._degree225 # Radius of background circle rx = self.width() / 2 ry = self.height() / 2 # Add r to have (0,0) in center of dial y = sin(angle) * (ry - self.knobRadius - self.knobMargin) + ry x = cos(angle) * (rx - self.knobRadius - self.knobMargin) + rx # Draw the ellipse painter.drawEllipse(QPointF(x, y), self.knobRadius, self.knobRadius)
def paintEvent(self, event): painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing) self._optionsRects = {} w, h = self.width(), self.height() metrics = self.fontMetrics() hphp = 2 * _hPad painter.save() path = QPainterPath() path.addRoundedRect(.5, .5, w - 1, h - 1, 4, 4) painter.fillPath(path, QColor(250, 250, 250)) x = 0 linePath = QPainterPath() for text in self._options[:-1]: x += hphp + metrics.width(text) linePath.moveTo(x, 0) linePath.lineTo(x, h) pen = painter.pen() pen.setColor(QColor(218, 218, 218)) pen.setWidth(0) painter.setPen(pen) painter.drawPath(path) painter.setRenderHint(QPainter.Antialiasing, False) painter.drawPath(linePath) painter.restore() painter.translate(_hPad, _vPad + metrics.ascent()) left = 0 for index, text in enumerate(self._options): if index in self._selection: color = QColor(20, 146, 230) else: color = QColor(63, 63, 63) painter.setPen(color) painter.drawText(0, 0, text) textWidth = metrics.width(text) rectWidth = textWidth + hphp rect = (left, 0, rectWidth, h) self._optionsRects[index] = rect painter.translate(rectWidth, 0) left += rectWidth
def parse_terrain_to_image(terrainfile, waterheight=None): # In BWii the entry at position 1 is not KNHC, but something else that needs to be skipped if terrainfile.entries[1].name != b"KNHC": off = 1 else: off = 0 tiles = terrainfile.entries[1+off] # KNHC #tiles2 = terrainfile.entries[4+off] # TWCU tilemap = terrainfile.entries[3+off] # PAMC #tilemapdata = bytes(tilemap.data) pic = QImage(64*4*4, 64*4*4, QImage.Format_ARGB32) light_pic = QImage(64*4*4, 64*4*4, QImage.Format_ARGB32) #colortransition = QImage(os.path.join("lib", "colors_terrainview.png"), "PNG") #colors = [] #for i in range(colortransition.width()): # colors.append(colortransition.pixel(i, 0)) """new = QImage(len(colors), 200, QImage.Format_ARGB32) trans_painter = QPainter() trans_painter.begin(new) for i in range(len(colors)): r, g, b = colors[i] pen = trans_painter.pen() pen.setColor(QColor(r, g, b)) trans_painter.setPen(pen) for y in range(200): trans_painter.drawPoint(i, y) trans_painter.end() result = new.save("transition.png", "PNG") print("saved", result)""" #pic = QPixmap(64*4*4, 64*4*4) p = QPainter() p.begin(pic) light_p = QPainter() light_p.begin(light_pic) biggestheight = 0 lowest = 0xFFFF print(len(tiles.data)/(180*16)) heights = [] watercolor = (106, 152, 242) lowest_values = {} total_lowest_color = None outofbounds_count = 0 for x in range(64): for y in range(64): a, b, offset = struct.unpack(">BBH", tilemap.data[(y*64+x)*4:(y*64+x+1)*4]) #print(a,b,offset) if b == 1: tiles_data = tiles.data[180*16*offset:180*16*(offset+1)] lowest = 0xFFFF lowest_color = None for ix in range(4): for iy in range(4): coord_offset = iy*4+ix single_tile = tiles_data[180*(coord_offset):180*(coord_offset+1)] if len(single_tile) == 0: print("Ooops:", offset) for iix in range(4): for iiy in range(4): point_offset = iiy*4 + iix #print("do stuff", (y*64+x)*4) height = struct.unpack(">H", single_tile[point_offset*2:(point_offset+1)*2])[0] light_r, light_g, light_b, unused = struct.unpack("BBBB", single_tile[32+point_offset*4:32+(point_offset+1)*4]) #blend_r, blend_g, blend_b, wat = struct.unpack("BBBB", # single_tile[4+32+64+point_offset*4:4+32+64+(point_offset+1)*4]) pen = p.pen() """if height > biggestheight: biggestheight = height if height < lowest: lowest = height if height not in heights: heights.append(height) if height >= 0x4FF: height -= 0x4FF pen.setColor(QColor(((height>>2)+50)&0xFF, ((height>>2)+50)&0xFF, ((height>>2)+50)&0xFF)) elif height >= 0x3F0: height -= 0x3F0 pen.setColor(QColor(((height>>2)+90)&0xFF, ((height>>2)+30)&0xFF, ((height>>2)+30)&0xFF)) elif height >= 0x1FF: height -= 0x1FF pen.setColor(QColor(0, ((height>>2)+30)&0xFF, 0)) else: pen.setColor(QColor(0, 0, ((height>>2)+30)&0xFF))""" if height >= len(COLORS): #print("oops, color out of bounds:", height, len(COLORS)) outofbounds_count += 1 height = len(COLORS)-1 r, g, b = COLORS[height] if waterheight is not None and height <= waterheight*16: r = (r+watercolor[0]) // 2 g = (r+watercolor[1]) // 2 b = (b+watercolor[2]) // 2 #r, g, b = watercolor if height < lowest: #and height > 0: lowest = height lowest_color = (r, g, b) total_lowest_color = (r, g, b) pen.setColor(QColor(r, g, b)) #pen.setColor(QColor(light_r, light_g, light_b)) #pen.setColor(QColor(blend_r, blend_g, blend_b)) #pen.setColor(QColor(blend_r, blend_g, blend_b)) #pen.setColor(QColor(height>>8, height&0xFF, height&0xFF)) p.setPen(pen) p.drawPoint(x*16+ix*4+iix, y*16+iy*4+iiy) pen.setColor(QColor(light_r, light_g, light_b)) light_p.setPen(pen) light_p.drawPoint(x*16+ix*4+iix, y*16+iy*4+iiy) lowest_values[(x,y)] = lowest_color p.end() light_p.end() print(pic.size().height(), pic.size().width()) print(biggestheight, hex(biggestheight)) print(lowest, hex(lowest)) heights.sort() print(heights) if outofbounds_count > 0: print("{0} points out of bounds".format(outofbounds_count)) finalimage = QImage(pic.width(), pic.height(), QImage.Format_ARGB32) p.begin(finalimage) #common_lowest_values = if waterheight is not None: """neighbours = {} for x in range(64): for y in range(64): if (x,y) in lowest_values: for i in range(-1, 1+1): for j in range(-1, 1+1): if (x+i, y+j) not in lowest_values: if (x+i, y+j) not in neighbours: neighbours[(x+i, y+j)] = [lowest_values[(x,y)]] else: neighbours[((x+i, y+j))].append(lowest_values[(x,y)]) all_lowest_values = [] for pos, values in neighbours.items(): all_lowest_values.extend(values) r, g, b = values[0] if len(values) > 1: for r2, g2, b2 in values[1:]: r = (r+r2)//2 g = (g+g2)//2 b = (b+b2)//2 current = 0#sum(values) // len(values) x,y = pos #r, g, b = colors[current] #all_lowest = sum(all_lowest_values) // len(all_lowest_values) #watercolor = (106, 152, 242) #colors[0x4F] color = colors[lowest] print("LOWEST IS", lowest) print(neighbours) r = (color[0]+watercolor[0]) // 2 g = (color[1]+watercolor[1]) // 2 b = (color[2]+watercolor[2]) // 2""" p.fillRect(0, 0, 64*64*4, 64*64*4, QColor(total_lowest_color[0], total_lowest_color[1], total_lowest_color[2])) p.drawImage(0, 0, pic) p.end() """p.begin(self.terrainview) p.drawImage(0, 0, pic) p.end()""" return finalimage.mirrored(False, True), light_pic.mirrored(False, True)#pic.mirrored(False, True)
def paintEvent(self, event): painter = QPainter(self) visibleRect = event.rect() columnCount = self._columnCount extra = self._cellWidthExtra cellWidth, cellHeight = self._cellWidth + 2 * extra, self._cellHeight glyphCount = len(self._glyphs) if columnCount: paintWidth = min(glyphCount, columnCount) * cellWidth else: paintWidth = 0 left = 0 top = cellHeight painter.fillRect(visibleRect, Qt.white) for index, glyph in enumerate(self._glyphs): t = top - cellHeight rect = (left, t, cellWidth, cellHeight) if visibleRect.intersects(visibleRect.__class__(*rect)): if index in self._selection: palette = self.palette() active = palette.currentColorGroup() != QPalette.Inactive opacityMultiplier = platformSpecific.colorOpacityMultiplier() selectionColor = palette.color(QPalette.Highlight) # TODO: alpha values somewhat arbitrary (here and in # glyphLineView) selectionColor.setAlphaF( .2 * opacityMultiplier if active else .7) painter.fillRect(QRectF( left, t, cellWidth, cellHeight), selectionColor) pixmap = self._getCurrentRepresentation(glyph) painter.drawPixmap(left, t, pixmap) # XXX: this hacks around the repr internals if index in self._selection and \ cellHeight >= GlyphCellMinHeightForHeader: painter.fillRect(QRectF( left, t + cellHeight - GlyphCellHeaderHeight, cellWidth, GlyphCellHeaderHeight), selectionColor) left += cellWidth if left + cellWidth > paintWidth: left = 0 top += cellHeight # drop insertion position dropIndex = self._currentDropIndex if dropIndex is not None: if columnCount: x = (dropIndex % columnCount) * cellWidth y = (dropIndex // columnCount) * cellHeight # special-case the end-column if dropIndex == glyphCount and \ glyphCount < self.width() // self._cellWidth or \ self.mapFromGlobal(QCursor.pos()).y() < y: x = columnCount * cellWidth y -= cellHeight else: x = y = 0 path = QPainterPath() path.addRect(x - 2, y, 3, cellHeight) path.addEllipse(x - 5, y - 5, 9, 9) path.addEllipse(x - 5, y + cellHeight - 5, 9, 9) path.setFillRule(Qt.WindingFill) pen = painter.pen() pen.setColor(Qt.white) pen.setWidth(2) painter.setPen(pen) painter.setRenderHint(QPainter.Antialiasing) painter.drawPath(path) painter.fillPath(path, insertionPositionColor)
class Renderer: def __init__(self, width, height, ownWindow=False): self.width = width self.height = height self.img = QImage(width, height, QImage.Format_RGB888) self.painter = QPainter() self.window = None if ownWindow: self.app = QApplication([]) self.window = Window() def close(self): """ Deallocate resources used """ pass def beginFrame(self): self.painter.begin(self.img) self.painter.setRenderHint(QPainter.Antialiasing, False) # Clear the background self.painter.setBrush(QColor(0, 0, 0)) self.painter.drawRect(0, 0, self.width - 1, self.height - 1) def endFrame(self): self.painter.end() if self.window: if self.window.closed: self.window = None else: self.window.setPixmap(self.getPixmap()) self.app.processEvents() def getPixmap(self): return QPixmap.fromImage(self.img) def getArray(self): """ Get a numpy array of RGB pixel values. The size argument should be (3,w,h) """ width = self.width height = self.height shape = (width, height, 3) numBytes = self.width * self.height * 3 buf = self.img.bits().asstring(numBytes) output = np.frombuffer(buf, dtype='uint8') output = output.reshape(shape) return output def push(self): self.painter.save() def pop(self): self.painter.restore() def rotate(self, degrees): self.painter.rotate(degrees) def translate(self, x, y): self.painter.translate(x, y) def scale(self, x, y): self.painter.scale(x, y) def setLineColor(self, r, g, b, a=255): self.painter.setPen(QColor(r, g, b, a)) def setColor(self, r, g, b, a=255): self.painter.setBrush(QColor(r, g, b, a)) def setLineWidth(self, width): pen = self.painter.pen() pen.setWidthF(width) self.painter.setPen(pen) def drawLine(self, x0, y0, x1, y1): self.painter.drawLine(x0, y0, x1, y1) def drawCircle(self, x, y, r): center = QPoint(x, y) self.painter.drawEllipse(center, r, r) def drawPolygon(self, points): """Takes a list of points (tuples) as input""" points = map(lambda p: QPoint(p[0], p[1]), points) self.painter.drawPolygon(QPolygon(points)) def fillRect(self, x, y, width, height, r, g, b, a=255): self.painter.fillRect(QRect(x, y, width, height), QColor(r, g, b, a))
def parse_terrain_to_image(terrainfile, waterheight=None): # In BWii the entry at position 1 is not KNHC, but something else that needs to be skipped if terrainfile.entries[1].name != b"KNHC": off = 1 else: off = 0 tiles = terrainfile.entries[1+off] # KNHC #tiles2 = terrainfile.entries[4+off] # TWCU tilemap = terrainfile.entries[3+off] # PAMC #tilemapdata = bytes(tilemap.data) pic = QImage(64*4*4, 64*4*4, QImage.Format_ARGB32) light_pic = QImage(64*4*4, 64*4*4, QImage.Format_ARGB32) #colortransition = QImage(os.path.join("lib", "colors_terrainview.png"), "PNG") #colors = [] #for i in range(colortransition.width()): # colors.append(colortransition.pixel(i, 0)) """new = QImage(len(colors), 200, QImage.Format_ARGB32) trans_painter = QPainter() trans_painter.begin(new) for i in range(len(colors)): r, g, b = colors[i] pen = trans_painter.pen() pen.setColor(QColor(r, g, b)) trans_painter.setPen(pen) for y in range(200): trans_painter.drawPoint(i, y) trans_painter.end() result = new.save("transition.png", "PNG") print("saved", result)""" #pic = QPixmap(64*4*4, 64*4*4) p = QPainter() p.begin(pic) light_p = QPainter() light_p.begin(light_pic) biggestheight = 0 lowest = 0xFFFF print(len(tiles.data)/(180*16)) heights = [] watercolor = (106, 152, 242) lowest_values = {} total_lowest_color = None for x in range(64): for y in range(64): a, b, offset = struct.unpack(">BBH", tilemap.data[(y*64+x)*4:(y*64+x+1)*4]) #print(a,b,offset) if b == 1: tiles_data = tiles.data[180*16*offset:180*16*(offset+1)] lowest = 0xFFFF lowest_color = None for ix in range(4): for iy in range(4): coord_offset = iy*4+ix single_tile = tiles_data[180*(coord_offset):180*(coord_offset+1)] if len(single_tile) == 0: print("Ooops:", offset) for iix in range(4): for iiy in range(4): point_offset = iiy*4 + iix #print("do stuff", (y*64+x)*4) height = struct.unpack(">H", single_tile[point_offset*2:(point_offset+1)*2])[0] light_r, light_g, light_b, unused = struct.unpack("BBBB", single_tile[32+point_offset*4:32+(point_offset+1)*4]) pen = p.pen() r = g = b = height//SCALE pen.setColor(QColor(r, g, b)) p.setPen(pen) p.drawPoint(x*16+ix*4+iix, y*16+iy*4+iiy) pen.setColor(QColor(light_r, light_g, light_b)) light_p.setPen(pen) light_p.drawPoint(x*16+ix*4+iix, y*16+iy*4+iiy) lowest_values[(x, y)] = lowest_color p.end() light_p.end() print(pic.size().height(), pic.size().width()) print(biggestheight, hex(biggestheight)) print(lowest, hex(lowest)) heights.sort() print(heights) finalimage = QImage(pic.width(), pic.height(), QImage.Format_ARGB32) p.begin(finalimage) p.drawImage(0, 0, pic) p.end() """p.begin(self.terrainview) p.drawImage(0, 0, pic) p.end()""" return finalimage.mirrored(False, True), light_pic.mirrored(False, True)#pic.mirrored(False, True)
def paintEvent(self, event): painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing) redrawRect = event.rect() beginRow = redrawRect.top() // self.squareSize endRow = redrawRect.bottom() // self.squareSize # XXX: do we need to maintain self._column when we have (endColumn - # beginColumn)? beginColumn = redrawRect.left() // self.squareSize endColumn = redrawRect.right() // self.squareSize gradient = QLinearGradient(0, 0, 0, GlyphCellHeaderHeight) gradient.setColorAt(0.0, cellHeaderBaseColor) gradient.setColorAt(1.0, cellHeaderLineColor) dirtyGradient = QLinearGradient(0, 0, 0, GlyphCellHeaderHeight) dirtyGradient.setColorAt(0.0, cellHeaderBaseColor.darker(125)) dirtyGradient.setColorAt(1.0, cellHeaderLineColor.darker(125)) markGradient = QLinearGradient(0, 0, 0, self.squareSize-GlyphCellHeaderHeight) for row in range(beginRow, endRow + 1): for column in range(beginColumn, endColumn + 1): key = row * self._columns + column if key >= len(self._glyphs): break glyph = self._glyphs[key] painter.save() painter.translate(column * self.squareSize, row * self.squareSize) painter.fillRect(0, 0, self.squareSize, self.squareSize, Qt.white) # prepare header colors brushColor = gradient linesColor = cellHeaderHighlightLineColor # mark color if not glyph.template: if glyph.markColor is not None: markColor = QColor.fromRgbF(*tuple(glyph.markColor)) markGradient.setColorAt(1.0, markColor) markGradient.setColorAt(0.0, markColor.lighter(125)) painter.fillRect(0, GlyphCellHeaderHeight, self.squareSize, self.squareSize - GlyphCellHeaderHeight, QBrush(markGradient)) if glyph.dirty: brushColor = dirtyGradient linesColor = cellHeaderHighlightLineColor.darker(110) # header gradient painter.fillRect(0, 0, self.squareSize, GlyphCellHeaderHeight, QBrush(brushColor)) # header lines painter.setPen(linesColor) minOffset = painter.pen().width() # disable antialiasing to avoid lines bleeding over background painter.setRenderHint(QPainter.Antialiasing, False) painter.drawLine(0, 0, 0, GlyphCellHeaderHeight - 1) painter.drawLine(self.squareSize - 2, 0, self.squareSize - 2, GlyphCellHeaderHeight -1) painter.setPen(QColor(170, 170, 170)) painter.drawLine(0, GlyphCellHeaderHeight, self.squareSize, GlyphCellHeaderHeight) painter.setRenderHint(QPainter.Antialiasing) # header text painter.setFont(headerFont) painter.setPen(QColor(80, 80, 80)) name = metrics.elidedText(glyph.name, Qt.ElideRight, self.squareSize - 2) painter.drawText(1, 0, self.squareSize - 2, GlyphCellHeaderHeight - minOffset, Qt.TextSingleLine | Qt.AlignCenter, name) painter.restore() painter.setPen(cellGridColor) rightEdgeX = column * self.squareSize + self.squareSize bottomEdgeY = row * self.squareSize + self.squareSize painter.drawLine(rightEdgeX, row * self.squareSize + 1, rightEdgeX, bottomEdgeY) painter.drawLine(rightEdgeX, bottomEdgeY, column * self.squareSize + 1, bottomEdgeY) if self._currentDropIndex is not None: painter.setPen(Qt.green) if self._currentDropIndex == key: painter.drawLine(column * self.squareSize, row * self.squareSize, column * self.squareSize, bottomEdgeY) # special-case the end-column elif column == endColumn and self._currentDropIndex == key+1: yPos = self.mapFromGlobal(QCursor.pos()).y() if row == yPos // self.squareSize: painter.drawLine(rightEdgeX - 1, row * self.squareSize, rightEdgeX - 1, bottomEdgeY) # selection code if key in self._selection: painter.setRenderHint(QPainter.Antialiasing, False) painter.fillRect(column * self.squareSize + 1, row * self.squareSize + 1, self.squareSize - 3, self.squareSize - 3, cellSelectionColor) painter.setRenderHint(QPainter.Antialiasing) if not glyph.template: font = glyph.getParent() outline = glyph.getRepresentation("defconQt.QPainterPath") uPM = font.info.unitsPerEm if uPM is None or not uPM > 0: uPM = 1000 descender = font.info.descender if descender is None or not descender < 0: descender = -250 factor = (self.squareSize-GlyphCellHeaderHeight) / (uPM*(1+2*GlyphCellBufferHeight)) x_offset = (self.squareSize-glyph.width*factor)/2 # If the glyph overflows horizontally we need to adjust the scaling factor if x_offset < 0: factor *= 1+2*x_offset/(glyph.width*factor) x_offset = 0 # TODO: the * 1.8 below is somewhat artificial y_offset = descender*factor * 1.8 painter.save() painter.setClipRect(column * self.squareSize, row * self.squareSize+GlyphCellHeaderHeight, self.squareSize, self.squareSize-GlyphCellHeaderHeight) painter.translate(column * self.squareSize + x_offset, row * self.squareSize + self.squareSize + y_offset) painter.scale(factor, -factor) painter.fillPath(outline, Qt.black) painter.restore() else: painter.save() painter.setFont(voidFont) painter.setPen(QPen(Qt.lightGray)) rect = QRectF(column * self.squareSize, row * self.squareSize+GlyphCellHeaderHeight, self.squareSize, self.squareSize-GlyphCellHeaderHeight) # TODO: need to flag template glyphs as to whether they have unicodings or not if glyph.unicode is not None: text = chr(glyph.unicode) else: text = "✌" painter.drawText(rect, Qt.AlignCenter, text) painter.restore()