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()
