def pixmap(name, size, mode, state):
"""Returns a (possibly cached) pixmap of the name and size with the default text color.
The state argument is ignored for now.
"""
if mode == QIcon.Selected:
color = QApplication.palette().highlightedText().color()
else:
color = QApplication.palette().text().color()
key = (name, size.width(), size.height(), color.rgb(), mode)
try:
return _pixmaps[key]
except KeyError:
i = QImage(size, QImage.Format_ARGB32_Premultiplied)
i.fill(0)
painter = QPainter(i)
# render SVG symbol
QSvgRenderer(os.path.join(__path__[0], name + ".svg")).render(painter)
# recolor to text color
painter.setCompositionMode(QPainter.CompositionMode_SourceIn)
painter.fillRect(i.rect(), color)
painter.end()
# let style alter the drawing based on mode, and create QPixmap
pixmap = QApplication.style().generatedIconPixmap(mode, QPixmap.fromImage(i), QStyleOption())
_pixmaps[key] = pixmap
return pixmap
def draw_indicator(indicator: int):
pixmap = QPixmap(24, 24)
painter = QPainter(pixmap)
w, h = pixmap.width(), pixmap.height()
painter.fillRect(0, 0, w, h, QBrush((QColor(0, 0, 200, 255))))
pen = QPen(QColor("white"))
pen.setWidth(2)
painter.setPen(pen)
font = util.get_monospace_font()
font.setBold(True)
font.setPixelSize(16)
painter.setFont(font)
f = QFontMetrics(painter.font())
indicator_str = str(indicator) if indicator < 10 else "+"
fw = f.width(indicator_str)
fh = f.height()
painter.drawText(math.ceil(w / 2 - fw / 2), math.ceil(h / 2 + fh / 4), indicator_str)
painter.end()
return QIcon(pixmap)
def paintEvent(self, ev):
if self.min is not None and self.max is not None:
opt = QStyleOptionSlider()
self.initStyleOption(opt)
opt.subControls = QStyle.SC_SliderGroove | QStyle.SC_SliderHandle
if self.tickPosition() != self.NoTicks:
opt.subControls |= QStyle.SC_SliderTickmarks
groove_rect = self.style().subControlRect(
QStyle.CC_Slider,
opt,
QStyle.SC_SliderGroove,
self
)
rect = QRect(
groove_rect.left() + self.min * groove_rect.width(),
groove_rect.top(),
(self.max-self.min) * groove_rect.width(),
groove_rect.height()
)
painter = QPainter(self)
painter.fillRect(rect, QBrush(Qt.red))
super(ColorRangeSlider, self).paintEvent(ev)
def paintEvent(self, event):
"""QWidget.paintEvent() implementation
"""
painter = QPainter(self)
painter.fillRect(event.rect(), self.palette().color(QPalette.Window))
painter.setPen(Qt.black)
block = self._qpart.firstVisibleBlock()
blockNumber = block.blockNumber()
top = int(self._qpart.blockBoundingGeometry(block).translated(self._qpart.contentOffset()).top())
bottom = top + int(self._qpart.blockBoundingRect(block).height())
singleBlockHeight = self._qpart.cursorRect().height()
boundingRect = self._qpart.blockBoundingRect(block)
while block.isValid() and top <= event.rect().bottom():
if block.isVisible() and bottom >= event.rect().top():
number = str(blockNumber + 1)
painter.drawText(0, top, self.__width - self._RIGHT_MARGIN - self._LEFT_MARGIN, self._qpart.fontMetrics().height(),
Qt.AlignRight, number)
if boundingRect.height() >= singleBlockHeight * 2: # wrapped block
painter.fillRect(1, top + singleBlockHeight,
self.__width - 2, boundingRect.height() - singleBlockHeight - 2,
Qt.darkGreen)
block = block.next()
boundingRect = self._qpart.blockBoundingRect(block)
top = bottom
bottom = top + int(boundingRect.height())
blockNumber += 1
def lineNumberAreaPaintEvent(self, event):
painter = QPainter(self.lineNumbers)
painter.fillRect(event.rect(), QColor(230, 230, 230))
d = event.rect().topRight()
a = event.rect().bottomRight()
painter.setPen(Qt.darkGray)
painter.drawLine(d.x(), d.y(), a.x(), a.y())
painter.setPen(QColor(100, 100, 100))
painter.setFont(self.font())
block = self.firstVisibleBlock()
blockNumber = block.blockNumber()
top = int(
self.blockBoundingGeometry(block).translated(
self.contentOffset()).top())
bottom = top + int(self.blockBoundingRect(block).height())
while block.isValid() and top <= event.rect().bottom():
if block.isVisible() and bottom >= event.rect().top():
number = str(blockNumber + 1)
painter.drawText(4, top, self.lineNumbers.width() - 8,
self.fontMetrics().height(), Qt.AlignRight,
number)
block = block.next()
top = bottom
bottom = top + int(self.blockBoundingRect(block).height())
blockNumber += 1
def mousePressEvent(self, event):
child = self.childAt(event.pos())
if not child:
return
pixmap = QPixmap(child.pixmap())
itemData = QByteArray()
dataStream = QDataStream(itemData, QIODevice.WriteOnly)
dataStream << pixmap << QPoint(event.pos() - child.pos())
mimeData = QMimeData()
mimeData.setData('application/x-dnditemdata', itemData)
drag = QDrag(self)
drag.setMimeData(mimeData)
drag.setPixmap(pixmap)
drag.setHotSpot(event.pos() - child.pos())
tempPixmap = QPixmap(pixmap)
painter = QPainter()
painter.begin(tempPixmap)
painter.fillRect(pixmap.rect(), QColor(127, 127, 127, 127))
painter.end()
child.setPixmap(tempPixmap)
if drag.exec_(Qt.CopyAction | Qt.MoveAction, Qt.CopyAction) == Qt.MoveAction:
child.close()
else:
child.show()
child.setPixmap(pixmap)
def paintEvent(self, event):
"""QWidget.paintEvent() implementation
Draw markers
"""
painter = QPainter(self)
painter.fillRect(event.rect(), self.palette().color(QPalette.Window))
block = self._qpart.firstVisibleBlock()
blockBoundingGeometry = self._qpart.blockBoundingGeometry(block).translated(self._qpart.contentOffset())
top = blockBoundingGeometry.top()
bottom = top + blockBoundingGeometry.height()
for block in qutepart.iterateBlocksFrom(block):
height = self._qpart.blockBoundingGeometry(block).height()
if top > event.rect().bottom():
break
if block.isVisible() and \
bottom >= event.rect().top():
if block.blockNumber() in self._qpart.lintMarks:
msgType, msgText = self._qpart.lintMarks[block.blockNumber()]
pixMap = self._lintPixmaps[msgType]
yPos = top + ((height - pixMap.height()) / 2) # centered
painter.drawPixmap(0, yPos, pixMap)
if self.isBlockMarked(block):
yPos = top + ((height - self._bookmarkPixmap.height()) / 2) # centered
painter.drawPixmap(0, yPos, self._bookmarkPixmap)
top += height
def paintEvent(self, event):
background = QRadialGradient(QPointF(self.rect().topLeft()), 500,
QPointF(self.rect().bottomRight()))
background.setColorAt(0, self.backgroundColor1)
background.setColorAt(1, self.backgroundColor2)
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.fillRect(event.rect(), QBrush(background))
painter.setPen(self.pen)
for bubble in self.bubbles:
if QRectF(bubble.position - QPointF(bubble.radius, bubble.radius),
QSizeF(2*bubble.radius, 2*bubble.radius)).intersects(QRectF(event.rect())):
bubble.drawBubble(painter)
if self.newBubble:
self.newBubble.drawBubble(painter)
painter.end()
def lineNumberAreaPaintEvent(self, event): # When text zoomed line number not zoomed
"""Painting line number area"""
painter = QPainter(self.lineNumberArea)
painter.fillRect(event.rect(), Qt.lightGray)
block = self.firstVisibleBlock()
blockNumber = block.blockNumber()
top = int(self.blockBoundingGeometry(block).translated(self.contentOffset()).top())
bottom = top + int(self.blockBoundingRect(block).height())
# font_height = self.fontMetrics().height()
while block.isValid() and top <= event.rect().bottom():
if block.isVisible() and bottom >= event.rect().top():
font_original = self.document().defaultFont()
size = font_original.pointSize()
font = painter.font()
font.setPointSize(size)
painter.setFont(font)
number = str(blockNumber + 1)
painter.setPen(Qt.black)
painter.drawText(0, top, self.lineNumberArea.width(),
self.fontMetrics().height(),
Qt.AlignRight, number)
block = block.next()
top = bottom
bottom = top + int(self.blockBoundingRect(block).height())
blockNumber += 1
def createListWidget(self):
listWidget = QListWidget()
w, h = self.ITEM_SIZE
scroll_size = 16
listWidget.setFixedWidth(w + scroll_size)
listWidget.setAttribute(Qt.WA_MacShowFocusRect, False)
for x in xrange(self._min_size, self._max_size):
h = max(x + self.MARGIN * 2.0, h)
pixmap = QPixmap(w, h)
pixmap.fill(Qt.transparent)
painter = QPainter(pixmap)
center = h / 2.0
painter.fillRect(QRectF(self.MARGIN, center - x / 2.0,
w - self.MARGIN * 2.0, x), Qt.black)
painter.end()
label = QLabel()
label.setPixmap(pixmap)
item = QListWidgetItem(listWidget)
item.setSizeHint(QSize(w, h))
item.setData(Qt.UserRole, x)
listWidget.addItem(item)
listWidget.setItemWidget(item, label)
if self._size == x:
listWidget.setCurrentItem(item)
return listWidget
def render(self, painter: QPainter) -> None:
if self._item_style == FileItemStyle.SMALLICON:
self.paint_smallicon_view(painter)
elif self._item_style == FileItemStyle.DETAIL:
self.paint_detail_view(painter)
else:
self.paint(painter)
if self.is_selected:
painter.save()
painter.setCompositionMode(QPainter.CompositionMode_SourceOver)
painter.setOpacity(0.5)
painter.fillRect(self.tile_rect, QColor(127, 192, 255))
painter.setCompositionMode(QPainter.CompositionMode_SourceOver)
painter.setOpacity(1.0)
painter.setPen(QColor(96, 127, 255))
painter.setBrush(Qt.NoBrush)
painter.drawRect(self.tile_rect)
painter.restore()
if self.is_cursor:
painter.setOpacity(1.0)
painter.setPen(QColor(0, 0, 0))
painter.setBrush(QColor(255, 255, 255, 96))
painter.drawRect(self.tile_rect)
def paintEvent(self, event):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
if self.hovered:
color = QColor(0, 0, 0, 90)
painter.fillRect(0, 0, self.width(), self.height(), color)
super(UnLockWindow, self).paintEvent(event)
def paintEvent(self, event):
super().paintEvent(event)
painter = QPainter(self)
for top, _, block in self._neditor.visible_blocks:
if not self.is_foldable_block(block):
continue
branch_rect = QRect(0, top, self.sizeHint().width(),
self.sizeHint().height())
opt = QStyleOptionViewItem()
opt.rect = branch_rect
opt.state = (QStyle.State_Active |
QStyle.State_Item |
QStyle.State_Children)
folded = self.user_data(block).get("folded", default=False)
if not folded:
opt.state |= QStyle.State_Open
# Draw item
self.style().drawPrimitive(QStyle.PE_IndicatorBranch, opt,
painter, self)
# Draw folded region background
if block == self.__mouse_over and not self.__timer.isActive():
fm_height = self._neditor.fontMetrics().height()
rect_height = 0
color = self.palette().highlight().color()
color.setAlpha(100)
if not folded:
foldable_blocks = self.code_folding.foldable_blocks(block)
rect_height = (len(list(foldable_blocks))) * fm_height
painter.fillRect(QRect(
0, top, self.sizeHint().width(),
rect_height + fm_height), color)
def paintEvent(self, event):
if self.isVisible():
background_color = QColor(
resources.COLOR_SCHEME.get("editor.sidebar.background"))
# resources.get_color('SidebarBackground'))
painter = QPainter(self)
painter.fillRect(event.rect(), background_color)
def paintEvent(self, ev):
color = self.palette().color(QPalette.Highlight)
painter = QPainter(self)
# Filled rectangle.
painter.setClipRect(self.rect())
color.setAlpha(50)
painter.fillRect(self.rect().adjusted(2,2,-2,-2), color)
# Thin rectangle outside.
color.setAlpha(150)
painter.setPen(color)
painter.drawRect(self.rect().adjusted(0,0,-1,-1))
# Pseudo-handles at the corners and sides
color.setAlpha(100)
pen = QPen(color)
pen.setWidth(8)
painter.setPen(pen)
painter.setBackgroundMode(Qt.OpaqueMode)
# Clip at 4 corners
region = QRegion(QRect(0,0,20,20))
region += QRect(self.rect().width()-20, 0, 20, 20)
region += QRect(self.rect().width()-20, self.rect().height()-20, 20, 20)
region += QRect(0, self.rect().height()-20, 20, 20)
# Clip middles
region += QRect(0, self.rect().height() // 2 - 10, self.rect().width(), 20)
region += QRect(self.rect().width() // 2 - 10, 0, 20, self.rect().height())
# Draw thicker rectangles, clipped at corners and sides.
painter.setClipRegion(region)
painter.drawRect(self.rect())
def paintEvent(self, e):
painter = QPainter(self)
w = self.width()
h = self.height()
painter.fillRect(0, 0, w, h, QBrush(QColor(255, 255, 255)))
self.drawCoordLines(painter, w, h)
self.drawModel(painter, w, h)
def paintEvent(self, event):
super().paintEvent(event)
painter = QPainter(self)
width = self.width() - self.RIGHT_MARGIN - self.LEFT_MARGIN
height = self._neditor.fontMetrics().height()
font = self._neditor.font()
font_bold = self._neditor.font()
font_bold.setBold(True)
pen = QPen(self._color_unselected)
painter.setPen(pen)
painter.setFont(font)
sel_start, sel_end = self._neditor.selection_range()
has_sel = sel_start != sel_end
current_line, _ = self._neditor.cursor_position
# Draw visible blocks
for top, line, block in self._neditor.visible_blocks:
# Set bold to current line and selected lines
if ((has_sel and sel_start <= line <= sel_end) or
(not has_sel and current_line == line)):
painter.fillRect(
QRect(0, top, self.width(), height), self._color_selected)
else:
painter.setPen(pen)
painter.setFont(font)
painter.drawText(self.LEFT_MARGIN, top, width, height,
Qt.AlignRight, str(line + 1))
def paintEvent(self, event):
"""This method draws a left sidebar
:param event: QEvent
"""
painter = QPainter(self)
painter.fillRect(event.rect(), Qt.white)
width = self.width() - 8
height = self.editor.fontMetrics().height()
font = self.editor.font()
font_bold = self.editor.font()
font_bold.setBold(True)
painter.setFont(font)
pen = QPen(Qt.gray)
painter.setPen(QPen(QColor("#e9e9e9")))
painter.drawLine(width + 7, 0, width + 7, event.rect().height())
painter.setPen(pen)
current_line = self.editor.textCursor().blockNumber()
for top, line, block in self.editor.visible_blocks:
if current_line == line:
painter.setFont(font_bold)
else:
painter.setFont(font)
painter.drawText(5, top, width, height,
Qt.AlignRight, str(line + 1))
def createEditor(self, parent: QWidget, option: QStyleOptionViewItem, index: QModelIndex):
editor = QComboBox(parent)
if sys.platform == "win32":
# Ensure text entries are visible with windows combo boxes
editor.setMinimumHeight(self.sizeHint(option, index).height() + 10)
editor.addItems(self.items)
if self.is_editable:
editor.setEditable(True)
editor.setInsertPolicy(QComboBox.NoInsert)
if self.current_edit_text:
editor.setEditText(self.current_edit_text)
if self.colors:
img = QImage(16, 16, QImage.Format_RGB32)
painter = QPainter(img)
painter.fillRect(img.rect(), Qt.black)
rect = img.rect().adjusted(1, 1, -1, -1)
for i, item in enumerate(self.items):
color = self.colors[i]
painter.fillRect(rect, QColor(color.red(), color.green(), color.blue(), 255))
editor.setItemData(i, QPixmap.fromImage(img), Qt.DecorationRole)
del painter
editor.currentIndexChanged.connect(self.currentIndexChanged)
editor.editTextChanged.connect(self.on_edit_text_changed)
return editor
def paintEvent(self, QPaintEvent):
self.updatePosition()
painter = QPainter(self)
painter.fillRect(self.rect(), Qt.transparent)
painter.setRenderHint(QPainter.Antialiasing, True)
if self._currentCounter >= self._numberOfLines:
self._currentCounter = 0
painter.setPen(Qt.NoPen)
for i in range(0, self._numberOfLines):
painter.save()
painter.translate(self._innerRadius + self._lineLength,
self._innerRadius + self._lineLength)
rotateAngle = float(360 * i) / float(self._numberOfLines)
painter.rotate(rotateAngle)
painter.translate(self._innerRadius, 0)
distance = self.lineCountDistanceFromPrimary(
i, self._currentCounter, self._numberOfLines)
color = self.currentLineColor(distance, self._numberOfLines,
self._trailFadePercentage,
self._minimumTrailOpacity,
self._color)
painter.setBrush(color)
rect = QRect(0, -self._lineWidth/2,
self._lineLength, self._lineWidth)
painter.drawRoundedRect(
rect, self._roundness, self._roundness, Qt.RelativeSize)
painter.restore()
def paintEvent(self, event):
painter = QPainter(self)
rect = event.rect()
rect.setWidth(self.__width())
painter.fillRect(rect, self._background_color)
painter.setPen(Qt.white)
font = self._console_widget.font()
painter.setFont(font)
width = self.__width()
height = self._console_widget.fontMetrics().height()
for top, line, block in self._console_widget.visible_blocks:
data = self.user_data(block)
prompt = data.get("prompt")
text = self.PROMPT_IN
color = Qt.white
if prompt is not None:
if prompt == self.PROMPT_INCOMPLETE:
text = self.PROMPT_INCOMPLETE
color = Qt.yellow
else:
text = self.PROMPT_OUT
color = Qt.gray
painter.setPen(color)
painter.drawText(0, top, width, height,
Qt.AlignCenter, text)
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.fillRect(event.rect(), QBrush(QColor(255, 255, 255, 127)))
painter.setPen(QPen(Qt.NoPen))
for i in range(6):
x_pos = self.width() / 2 + 30 * \
math.cos(2 * math.pi * i / 6.0) - 10
y_pos = self.height() / 2 + 30 * \
math.sin(2 * math.pi * i / 6.0) - 10
if (self.counter / 5) % 6 == i:
linear_gradient = QLinearGradient(
x_pos + 10, x_pos, y_pos + 10, y_pos)
linear_gradient.setColorAt(0, QColor(135, 206, 250))
linear_gradient.setColorAt(1, QColor(0, 0, 128))
painter.setBrush(QBrush(linear_gradient))
else:
linear_gradient = QLinearGradient(
x_pos - 10, x_pos, y_pos + 10, y_pos)
linear_gradient.setColorAt(0, QColor(105, 105, 105))
linear_gradient.setColorAt(1, QColor(0, 0, 0))
painter.setBrush(QBrush(linear_gradient))
painter.drawEllipse(
x_pos,
y_pos,
20, 20)
painter.end()
def paintEvent(self, event):
if not globalSettings.lineNumbersEnabled:
return QWidget.paintEvent(self, event)
painter = QPainter(self)
painter.fillRect(event.rect(), colorValues['lineNumberArea'])
painter.setPen(colorValues['lineNumberAreaText'])
cursor = self.editor.cursorForPosition(QPoint(0, 0))
atEnd = False
fontHeight = self.fontMetrics().height()
height = self.editor.height()
if globalSettings.relativeLineNumbers:
relativeTo = self.editor.textCursor().blockNumber()
else:
relativeTo = -1
while not atEnd:
rect = self.editor.cursorRect(cursor)
if rect.top() >= height:
break
number = str(cursor.blockNumber() - relativeTo).replace('-', '−')
painter.drawText(0, rect.top(), self.width() - 2,
fontHeight, Qt.AlignRight, number)
cursor.movePosition(QTextCursor.EndOfBlock)
atEnd = cursor.atEnd()
if not atEnd:
cursor.movePosition(QTextCursor.NextBlock)
def paintEvent(self, event):
QWidget.paintEvent(self, event)
self.update_cache()
if not self.cache:
return
rect = self._nscrollbar.overlay_rect()
sb_range = self._nscrollbar.get_scrollbar_range()
sb_range = max(self.visible_range, sb_range)
# horizontal_margin = 3
# result_width = rect.width() - 2 * horizontal_margin + 1
result_width = rect.width() / 3
result_height = min(rect.height() / sb_range + 1, 4)
# x = rect.left() + horizontal_margin
x = rect.center().x() - 1
offset = rect.height() / sb_range * self.range_offset
vertical_margin = ((rect.height() / sb_range) - result_height) / 2
painter = QPainter(self)
for lineno in self.cache.keys():
marker = self.cache[lineno]
top = rect.top() + offset + vertical_margin + \
marker.position / sb_range * rect.height()
# bottom = top + result_height
painter.fillRect(
x,
top,
result_width,
4,
QColor(marker.color))
def numPaintEvent(self, event):
"""
Paint the editor
:param event:
:return:
"""
painter = QPainter(self.numArea)
painter.fillRect(event.rect(), Qt.lightGray)
block = self.firstVisibleBlock()
block_num = block.blockNumber()
top = self.blockBoundingGeometry(block).translated(self.contentOffset()).top()
bottom = top + self.blockBoundingRect(block).height()
while block.isValid() and top <= event.rect().bottom():
if block.isVisible() and bottom >= event.rect().top():
number = block_num + 1
painter.setPen(Qt.darkRed)
painter.drawText(0, top, self.numArea.width(), self.fontMetrics().height(),
Qt.AlignRight, ' %s ' % str(number)) # padding
block = block.next()
top = bottom
bottom = top + self.blockBoundingRect(block).height()
block_num += 1
def paintGL(self):
from PyQt5.QtGui import QBrush, QPen, QColor, QPainter
from PyQt5.QtCore import QPointF
painter = QPainter(self)
painter.setPen(QPen(QColor(0, 0, 0, 0), 0))
painter.fillRect(0, 0, self.width(), self.height(), QColor(0, 0, 0))
for strand_id, strand in self.scene.strands.items():
if strand is None: continue
spacing = 4 if self._blur else 1
instructions = list(zip(self.locations[strand_id][::spacing],
strand.all_contents[::spacing]))
if self._blur:
for (x, y), (r, g, b) in instructions:
painter.setBrush(QColor(r, g, b, 50))
painter.drawEllipse(QPointF(x, y), 16, 16)
for (x, y), (r, g, b) in instructions:
painter.setBrush(QColor(r, g, b, 50))
painter.drawEllipse(QPointF(x, y), 6, 6)
painter.setBrush(QColor(r, g, b, 255))
painter.drawEllipse(QPointF(x, y), 3, 3)
def __paintRectangular(self):
"""
Private method to paint a rectangular raised LED.
"""
# Initialize coordinates, width and height of the LED
width = self.height() * self.__rectRatio
left = max(0, int((self.width() - width) / 2) - 1)
right = min(int((self.width() + width) / 2), self.width())
height = self.height()
# now do the drawing
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing, True)
color = self.__led_on and self.__led_color or self.__offcolor
painter.setPen(color.lighter(200))
painter.drawLine(left, 0, left, height - 1)
painter.drawLine(left + 1, 0, right - 1, 0)
if self.__framedLed:
painter.setPen(self.palette().color(QPalette.Dark))
else:
painter.setPen(color.darker())
painter.drawLine(left + 1, height - 1, right - 1, height - 1)
painter.drawLine(right - 1, 1, right - 1, height - 1)
painter.fillRect(left + 1, 1, right - 2, height - 2, QBrush(color))
painter.end()
def createImage(self, transform):
original = QImage(self.image)
if original.isNull():
return original
size = transform.map(QPoint(self.maxWidth, self.maxHeight))
w = size.x()
h = size.y()
# Optimization: if image is smaller than maximum allowed size, just
# return the loaded image.
if original.size().height() <= h and original.size().width() <= w and not self.adjustSize and self.scale == 1:
return original
# Calculate what the size of the final image will be.
w = min(w, float(original.size().width()) * self.scale)
h = min(h, float(original.size().height()) * self.scale)
adjustx = 1.0
adjusty = 1.0
if self.adjustSize:
adjustx = min(transform.m11(), transform.m22())
adjusty = max(transform.m22(), adjustx)
w *= adjustx
h *= adjusty
# Create a new image with correct size, and draw original on it.
image = QImage(int(w + 2), int(h + 2),
QImage.Format_ARGB32_Premultiplied)
image.fill(QColor(0, 0, 0, 0).rgba())
painter = QPainter(image)
painter.setRenderHints(QPainter.Antialiasing | QPainter.SmoothPixmapTransform)
if self.adjustSize:
painter.scale(adjustx, adjusty)
if self.scale != 1:
painter.scale(self.scale, self.scale)
painter.drawImage(0, 0, original)
if not self.adjustSize:
# Blur out edges.
blur = 30
if h < original.height():
brush1 = QLinearGradient(0, h - blur, 0, h)
brush1.setSpread(QLinearGradient.PadSpread)
brush1.setColorAt(0.0, QColor(0, 0, 0, 0))
brush1.setColorAt(1.0, Colors.sceneBg1)
painter.fillRect(0, int(h) - blur, original.width(), int(h),
brush1)
if w < original.width():
brush2 = QLinearGradient(w - blur, 0, w, 0)
brush2.setSpread(QLinearGradient.PadSpread)
brush2.setColorAt(0.0, QColor(0, 0, 0, 0))
brush2.setColorAt(1.0, Colors.sceneBg1)
painter.fillRect(int(w) - blur, 0, int(w), original.height(),
brush2)
return image
def createColorIcon(self, color):
pixmap = QPixmap(20, 20)
painter = QPainter(pixmap)
painter.setPen(Qt.NoPen)
painter.fillRect(QRect(0, 0, 20, 20), color)
painter.end()
return QIcon(pixmap)
def paintEvent(self,event): super().paintEvent(event) painter = QPainter(self) painter.fillRect(4,4,frameWidth,frameHeight,self.backBrush) painter.drawPixmap(4+(frameWidth-self.pixMap.width())//2,4+(frameHeight-self.pixMap.height())//2,self.pixMap) if self.isChecked(): painter.setPen(self.checkedPen) painter.drawRect(3,3,self.width()-6,self.height()-6)
def checkerBoardBrush(size=32):
"""Return a checker board brush"""
tmpPixmap = QPixmap(size,size)
tmpPixmap.fill(QColor(255,255,255))
brush = QBrush(QColor(220,220,220))
canvas = QPainter()
canvas.begin(tmpPixmap)
canvas.setPen(Qt.NoPen)
s1 = size>>1
s2 = size - s1
canvas.setRenderHint(QPainter.Antialiasing, False)
canvas.fillRect(QRect(0, 0, s1, s1), brush)
canvas.fillRect(QRect(s1, s1, s2, s2), brush)
canvas.end()
return QBrush(tmpPixmap)
def _validateImage(self):
if (self._sharedImage.transform != DemoItem._transform and
not Colors.noRescale) or (self._sharedImage.image is None and
self._sharedImage.pixmap is None):
# (Re)create image according to new transform.
self._sharedImage.image = None
self._sharedImage.pixmap = None
self._sharedImage.transform = DemoItem._transform
# Let subclass create and draw a new image according to the new
# transform.
if Colors.noRescale:
transform = QTransform()
else:
transform = DemoItem._transform
image = self.createImage(transform)
if image is not None:
if Colors.showBoundingRect:
# Draw red transparent rect.
painter = QPainter(image)
painter.fillRect(image.rect(), QColor(255, 0, 0, 50))
painter.end()
self._sharedImage.unscaledBoundingRect = self._sharedImage.transform.inverted(
)[0].mapRect(QRectF(image.rect()))
if Colors.usePixmaps:
if image.isNull():
self._sharedImage.pixmap = QPixmap(1, 1)
else:
self._sharedImage.pixmap = QPixmap(image.size())
self._sharedImage.pixmap.fill(QColor(0, 0, 0, 0))
painter = QPainter(self._sharedImage.pixmap)
painter.drawImage(0, 0, image)
else:
self._sharedImage.image = image
return True
else:
return False
return True
def paintEvent(self, _):
opt = QStyleOption()
opt.initFrom(self)
painter = QPainter(self)
self.style().drawPrimitive(QStyle.PE_Widget, opt, painter, self)
if self.show_pieces:
piece_width = self.width() / float(len(self.pieces))
for i in xrange(len(self.pieces)):
if self.pieces[i]:
painter.fillRect(
QRect(
float(i) * piece_width, 0, math.ceil(piece_width),
self.height()), QColor(230, 115, 0))
else:
painter.fillRect(
QRect(0, 0,
self.width() * self.fraction, self.height()),
QColor(230, 115, 0))
def _drawGridRanges(self, painter: QPainter):
"""отрисовка области рабочего диапазона"""
# logger.debug(self._drawGridRanges.__doc__)
self._calculateRanges()
# расчёт раб.диапазона
x_0 = int(self._margins[0] + self._range_pixels[0])
x_1 = int(self._margins[0] + self._range_pixels[1])
x_2 = int(self._margins[0] + self._range_pixels[2])
y_0 = int(self._margins[1])
y_1 = int(self.getDrawArea().height() + y_0)
# отрисовка раб.диапазона
pen = painter.pen()
painter.setPen(self._style['grid']['border'])
painter.fillRect(x_0, y_0, x_2 - x_0, y_1 - y_0,
self._style['grid']['ranges'])
painter.drawLine(x_0, y_0, x_0, y_1)
painter.drawLine(x_1, y_0, x_1, y_1)
painter.drawLine(x_2, y_0, x_2, y_1)
painter.setPen(pen)
def paintEvent(self, event):
painter = QPainter(self)
if self.isEnabled() and not self.isDown() and not self.isChecked():
painter.save()
hover_color = QColor("#424242")
faded_hover_color = QColor(hover_color)
faded_hover_color.setAlpha(int(self._fader * hover_color.alpha()))
painter.fillRect(event.rect(), faded_hover_color)
painter.restore()
elif self.isDown() or self.isChecked():
painter.save()
selected_color = QColor("#090909")
painter.fillRect(event.rect(), selected_color)
painter.restore()
rect = event.rect()
icon_rect = QRect(0, 0, 22, 22)
self.icon().paint(painter, icon_rect, Qt.AlignVCenter)
painter.drawText(rect.adjusted(0, 0, -3, 0),
Qt.AlignRight | Qt.AlignVCenter, self.text())
def paintEvent(self, event):
if self._drawingCommands is None:
return
painter = QPainter(self)
rect = event.rect()
target = self.rect().size()
size = self._drawingCommands[0]
if not size.isNull() and (
size.width() < target.width() or size.height() < target.height()
):
dx = dy = 0
if size.width() < target.width():
dx = int(0.5 * (target.width() - size.width()))
if size.height() < target.height():
dy = int(0.5 * (target.height() - size.height()))
painter.translate(dx, dy)
isDown = self.isDown() and self._isDownColor is not None
if isDown and self._isDownColor.isValid():
painter.fillRect(rect, self._isDownColor)
isDown = False
if self._isFlipped:
painter.translate(0, target.height())
painter.scale(1, -1)
for path, cmd, color in self._drawingCommands[1:]:
if cmd == "f":
if isDown:
color = color.darker(120)
painter.save()
painter.setRenderHint(QPainter.Antialiasing)
painter.fillPath(path, color)
painter.restore()
else:
if isDown:
color = color.darker(150)
painter.save()
if cmd[-1] == "a":
painter.setRenderHint(QPainter.Antialiasing)
pen = painter.pen()
pen.setColor(color)
pen.setWidth(int(cmd[0]))
painter.setPen(pen)
painter.drawPath(path)
painter.restore()
def drawPixmapFor2d(self):
self.pixmap2d = QPixmap(self.itemWidth, self.itemHeight)
self.pixmap2d.fill(Qt.transparent)
painter = QPainter()
painter.begin(self.pixmap2d)
painter.setRenderHint(QPainter.Antialiasing)
pen = QPen()
pen.setWidth(2)
painter.setPen(pen)
painter.drawRect(QRect(5, 5, self.itemWidth - 10,
self.itemHeight - 10))
painter.fillRect(
QRect(5, 5, self.itemWidth - 10, self.itemHeight - 10),
QColor(0, 250, 154))
painter.drawText(
QRect(5, 5, self.itemWidth - 10, self.itemHeight - 10),
Qt.AlignCenter, "2D")
painter.end()
def paintEvent(self, event):
painter = QPainter(self)
if self.isEnabled() and not self.isDown() and not self.isChecked():
painter.save()
hover_color = QColor("#424242")
faded_hover_color = QColor(hover_color)
faded_hover_color.setAlpha(int(self._fader * hover_color.alpha()))
painter.fillRect(event.rect(), faded_hover_color)
painter.restore()
elif self.isDown() or self.isChecked():
painter.save()
selected_color = QColor("#161719")
painter.fillRect(event.rect(), selected_color)
painter.restore()
is_titled = bool(self.defaultAction().property("titled"))
icon_rect = QRect(0, 0, 32, 32)
icon_rect.moveCenter(event.rect().center())
if is_titled:
font = painter.font()
center_rect = event.rect()
font.setPointSizeF(6)
fm = QFontMetrics(font)
line_height = fm.height()
text_flags = Qt.AlignHCenter | Qt.AlignTop
project_name = self.defaultAction().property("heading")
if project_name is not None:
center_rect.adjust(0, line_height, 0, 0)
icon_rect.moveTop(center_rect.top())
else:
icon_rect.moveCenter(center_rect.center())
self.icon().paint(painter, icon_rect, Qt.AlignCenter)
painter.setFont(font)
r = QRect(0, 5, self.rect().width(), line_height)
painter.setPen(Qt.white)
margin = 5
available_width = r.width() - margin
ellided_project_name = fm.elidedText(project_name, Qt.ElideMiddle,
available_width)
painter.drawText(r, text_flags, ellided_project_name)
else:
self.icon().paint(painter, icon_rect, Qt.AlignCenter)
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.fillRect(event.rect(), QBrush(QColor(255, 255, 255, 127)))
painter.setPen(QPen(Qt.NoPen))
for i in range(6):
if self.counter % 6 == i:
painter.setBrush(QBrush(QColor(0, 0, 0)))
else:
painter.setBrush(QBrush(QColor(200, 200, 200)))
painter.drawEllipse(
self.width() / 2 + 30 * math.cos(2 * math.pi * i / 6.0) - 10,
self.height() / 2 + 30 * math.sin(2 * math.pi * i / 6.0) - 10,
20, 20)
painter.end()
def paintEvent(self, event):
painter = QPainter(self)
painter.setFont(UIFont)
painter.setRenderHint(QPainter.Antialiasing)
rect = self.rect()
# draw the background
painter.fillRect(rect, self._backgroundColor)
if self._glyph is None:
return
# apply the overall scale
painter.save()
# + translate and flip
painter.translate(0, self.height())
painter.scale(self._scale, -self._scale)
# move into position
xOffsetInv, yOffsetInv, _, _ = self._drawingRect
painter.translate(-xOffsetInv, -yOffsetInv)
# gather the layers
layerSet = self._glyph.layerSet
if layerSet is None:
layers = [(self._glyph, None)]
else:
glyphName = self._glyph.name
layers = []
for layerName in reversed(layerSet.layerOrder):
layer = layerSet[layerName]
if glyphName not in layer:
continue
glyph = layer[glyphName]
if glyph == self._glyph:
layerName = None
layers.append((glyph, layerName))
self.drawBackground(painter)
for glyph, layerName in layers:
self.drawGlyphLayer(painter, glyph, layerName)
self.drawForeground(painter)
painter.restore()
def paintEvent(self, event):
p = QPainter()
color = QStyleParser.getColor(self.styleSheet(), 'color: rgb')
pen = QPen(color.lighter(75))
rect = self.geometry()
p.begin(self)
# if log type fillbar
if self._logarithmic:
self._intFullscale = self._fullscale_dB
if self._level != 0:
self._intLevel = self._intFullscale - 20 * math.log10(
(self._max - self._min) / self._level)
else:
self._intLevel = 0
else:
self._intFullscale = self._max - self._min
self._intLevel = self._level
# calc and draw respect orientation
if self._orientation == Qt.Horizontal:
_width = self._intLevel * (rect.width() / self._intFullscale)
_height = rect.height()
p.fillRect(0, 0, _width, _height, color)
else:
_width = rect.width() - 1
_height = self._intLevel * (rect.height() / self._intFullscale)
p.fillRect(0, (rect.height() - _height) + 1, _width, _height,
color)
# draw border
if self._border:
p.setPen(pen)
p.drawRect(QRect(0, 0, rect.width() - 1, rect.height() - 1))
# draw markers
if self._markers:
self._paintMarkers(rect, p)
p.end()
def paintEvent(self, e):
qp = QPainter()
qp.begin(self)
fr = self.frameRect()
b = self.lineWidth()
fr.adjust(b, b, -b, -b)
qp.fillRect(fr, QColor(255, 255, 255))
def bzsez():
g = 100
pen = QPen(QColor(255, 0, 0, 255 - g))
qp.setPen(pen)
font = QFont(qp.font())
font.setPixelSize(self.width() / 10)
qp.setFont(font)
qp.drawText(fr, Qt.AlignCenter,
"Bitte zeichnen Sie\neine Zahl von 0-9!")
#bzsez()
for i, p in enumerate(reversed(self.paths)):
if i > 0:
pen = QPen(QColor(0, 0, 0, 20 - 20 * i / self.max_paths))
else:
pen = QPen(Qt.black)
pen.setWidth(self.width() / 32.0)
pen.setJoinStyle(Qt.RoundJoin)
pen.setCapStyle(Qt.RoundCap)
qp.setPen(pen)
qp.drawPath(p)
if self.recreatePath:
bzsez()
qp.end()
super().paintEvent(e)
def paintEvent(self, e):
p = QPainter(self)
# Paint border
bar_rect = self.rect().adjusted(0, 15, 0, -1)
if self._background is not None:
p.drawTiledPixmap(bar_rect, self._background)
pen = QPen()
pen.setColor(Qt.black)
pen.setWidth(1)
p.setPen(pen)
bar_rect.adjust(0, 0, -1, 0)
p.drawRect(bar_rect)
p.setPen(Qt.white)
# Paint Spectrum
bar_rect.adjust(1, 1, 0, 0)
p.fillRect(bar_rect, QBrush(self._gradient))
# Paint Picker
p.drawPixmap(self._pickRect, self._pickerPixmap)
# Draw Label
label_rect = QRect(200, 1, 20, 15)
p.drawText(label_rect, Qt.AlignRight, str(self._value))
if len(self._label) > 0:
label_rect.adjust(-200, 0, 0, 0)
p.drawText(label_rect, Qt.AlignLeft, self._label)
def paintEvent(self, event):
p = QPainter()
color = QStyleParser.getColor(self.styleSheet(), 'color: rgb')
rect = self.geometry()
# calc and draw respect orientation
fullscale = self._max - self._min
slider_size = self._slider_size
p.begin(self)
# calc slider respect orientation
if self._orientation == Qt.Horizontal:
posX = self._level * (rect.width() / fullscale)
posY = rect.height() / 2
else:
posX = rect.width() / 2
posY = rect.height() - ((self._level * rect.height()) / fullscale)
# calc coordinates respect orientation
rect_0, rect_1, color_0, color_1 = self._calcCoordinates(posX, posY, slider_size)
# draw seekbar
p.fillRect(rect_0, color_0)
p.setPen(color_0)
p.drawRect(rect_0)
p.fillRect(rect_1, color_1)
p.setPen(color_1)
p.drawRect(rect_1)
# draw slider
for i in range(min(slider_size.width(), slider_size.height())):
p.setPen(self._slider_color.lighter(100 + (i * 10)))
p.drawRect(posX - (slider_size.width() - i) // 2,
posY - (slider_size.height() - i) // 2,
slider_size.width() - i,
slider_size.height() - i)
p.end()
def paintEvent(self, event): if not globalSettings.lineNumbersEnabled: return QWidget.paintEvent(self, event) painter = QPainter(self) painter.fillRect(event.rect(), colorValues['lineNumberArea']) cursor = QTextCursor(self.editor.document()) cursor.movePosition(QTextCursor.Start) atEnd = False while not atEnd: rect = self.editor.cursorRect(cursor) block = cursor.block() if block.isVisible(): number = str(cursor.blockNumber() + 1) painter.setPen(colorValues['lineNumberAreaText']) painter.drawText(0, rect.top(), self.width() - 2, self.fontMetrics().height(), Qt.AlignRight, number) cursor.movePosition(QTextCursor.EndOfBlock) atEnd = cursor.atEnd() if not atEnd: cursor.movePosition(QTextCursor.NextBlock)
def paintEvent(self, event):
painter = QPainter(self)
painter.fillRect(event.rect(), self.numberBarColor)
block = self.editor.firstVisibleBlock()
while block.isValid():
blockNumber = block.blockNumber()
block_top = self.editor.blockBoundingGeometry(
block).translated(self.editor.contentOffset()).top()
if blockNumber == self.editor.textCursor().blockNumber():
self.font.setBold(True)
painter.setPen(QColor("#000000"))
else:
self.font.setBold(False)
painter.setPen(QColor("#717171"))
paint_rect = QRect(0, block_top, self.width(),
self.editor.fontMetrics().height())
painter.drawText(paint_rect, Qt.AlignCenter,
str(blockNumber + 1))
block = block.next()
def createReflectedImage(self):
self.refImage = QImage(self.iw, self.ih, QImage.Format_ARGB32)
painter = QPainter()
painter.begin(self.refImage)
painter.drawImage(0, 0, self.img)
mode = QPainter.CompositionMode_DestinationIn
painter.setCompositionMode(mode)
gradient = QLinearGradient(self.iw / 2, 0, self.iw / 2, self.ih)
gradient.setColorAt(1, QColor(0, 0, 0))
gradient.setColorAt(0, Qt.transparent)
painter.fillRect(0, 0, self.iw, self.ih, gradient)
painter.end()
def paintEvent(self, event):
painter = QPainter(self)
painter.setFont(self.font)
painter.fillRect(0, 0, self.width(), self.height(), QColor(self.theme[1]))
dev = (self.width()/300)*2
for i in range(0, 3):
pos = 5+i*self.height()*dev+2*(i*2)
if(i != self.sellected):
painter.setPen(QColor(self.backgrounds[i]))
painter.drawRect(pos, 5, self.height()*dev, self.height()-10)
painter.drawText(pos + (self.height() * dev) * 0.5 - QFontMetrics(self.font).width(self.texts[i])*0.5, self.height()*0.5+self.font.pointSize()*0.5, self.texts[i])
else:
painter.fillRect(pos, 5, self.height()*dev, self.height()-10, QColor(self.theme[4]))
painter.setPen(QColor(self.backgrounds[i]))
painter.drawRect(pos, 5, self.height()*dev, self.height()-10)
painter.setPen(QColor(self.theme[5]))
painter.drawText(pos + (self.height() * dev) * 0.5 - QFontMetrics(self.font).width(self.texts[i])*0.5, self.height()*0.5+self.font.pointSize()*0.5, self.texts[i])
def paintEvent(self, event):
edit = self.edit
font_metrics = edit.fontMetrics()
block = edit.firstVisibleBlock()
count = block.blockNumber()
painter = QPainter(self)
painter.fillRect(event.rect(), edit.palette().base())
first = True
while block.isValid():
count += 1
block_top = edit.blockBoundingGeometry(block).translated(
edit.contentOffset()).top()
if not block.isVisible() or block_top > event.rect().bottom():
break
rect = QRect(0, block_top, self.width(), font_metrics.height())
self.draw_block(painter, rect, block, first)
first = False
block = block.next()
painter.end()
super().paintEvent(event)
def repaint_line_number_area(self, event):
painter = QPainter(self.line_number_area)
painter.fillRect(event.rect(), Qt.lightGray)
block = self.firstVisibleBlock()
block_number = block.blockNumber()
top = int(
self.blockBoundingGeometry(block).translated(
self.contentOffset()).top())
bottom = top + int(self.blockBoundingGeometry(block).height())
while block.isValid() and top <= event.rect().bottom():
if block.isVisible() and bottom >= event.rect().top():
number = str(block_number + 1)
painter.setPen(Qt.black)
painter.drawText(-2, top, self.line_number_area.width(),
self.fontMetrics().height(), Qt.AlignRight,
number)
block = block.next()
top = bottom
bottom = top + int(self.blockBoundingGeometry(block).height())
block_number += 1
def paintEvent(self, event):
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
rectangle = event.rect()
if self.isHead:
color = Qt.darkYellow
elif self.isSnake:
color = Qt.darkGreen
elif self.isApple:
color = Qt.darkRed
else:
color = Qt.lightGray
painter.fillRect(rectangle, QBrush(color))
pen = QPen(color)
pen.setWidth(1)
painter.setPen(pen)
painter.drawRect(rectangle)
def lineNumberAreaPaintEvent(self, event):
painter = QPainter(self.lineNumberArea)
painter.fillRect(event.rect(), Qt.cyan)
cursor = QTextCursor(self.document())
cursor.movePosition(QTextCursor.Start)
atEnd = False
while not atEnd:
rect = self.cursorRect(cursor)
block = cursor.block()
if block.isVisible():
number = str(cursor.blockNumber() + 1)
painter.setPen(Qt.darkCyan)
painter.drawText(0, rect.top(),
self.lineNumberArea.width() - 2,
self.fontMetrics().height(), Qt.AlignRight,
number)
cursor.movePosition(QTextCursor.EndOfBlock)
atEnd = cursor.atEnd()
if not atEnd:
cursor.movePosition(QTextCursor.NextBlock)
def lineNumberAreaPaintEvent(self, event):
"""This method draws the current lineNumberArea for while"""
painter = QPainter(self.lineNumberArea)
painter.fillRect(event.rect(), QColor(Qt.lightGray).darker(300))
block = self.firstVisibleBlock()
blockNumber = block.blockNumber()
top = int(self.blockBoundingGeometry(block).translated(self.contentOffset()).top())
bottom = top + int(self.blockBoundingRect(block).height())
while block.isValid() and top <= event.rect().bottom():
if block.isVisible() and bottom >= event.rect().top():
number = str(blockNumber + 1)
painter.setPen(QColor(Qt.lightGray))
painter.drawText(0, top, self.lineNumberArea.width(), self.fontMetrics().height(),
Qt.AlignRight, number)
block = block.next()
top = bottom
bottom = top + int(self.blockBoundingRect(block).height())
blockNumber += 1
def drawWidget(self, qp: QPainter):
colors = [
QColor(0xff, 0xff, 0xff), # 0x00 bg
QColor(0xc0, 0xa0, 0xa0), # 1
QColor(0xc0, 0x00, 0x60), # 2
QColor(0xc0, 0x60, 0x00), # 3
QColor(0xa0, 0xc0, 0x20), # 4
QColor(0x00, 0xc0, 0x80), # 5
QColor(0x40, 0x80, 0x80), # 6
QColor(0x80, 0x40, 0xc0), # 7
QColor(0x40, 0x40, 0xc0), # 8
QColor(0x40, 0xa0, 0xc0), # 9
QColor(0x40, 0x40, 0x40), # -2 sel
QColor(0x00, 0x00, 0x00),
] # -1 border
for i in range(0, self.hanoi.rows):
for j in range(0, self.hanoi.cols):
h = self.hanoi.M[i, j]
qp.fillRect(j * self.xrate, i * self.yrate, self.xrate,
self.yrate, colors[h])
def drawCropBox(self):
pm = self.pm_tmp.copy()
pm_box = pm.copy(self.p1.x(), self.p1.y(),
self.p2.x() - self.p1.x(),
self.p2.y() - self.p1.y())
painter = QPainter(pm)
painter.fillRect(0, 0, pm.width(), pm.height(),
QColor(127, 127, 127, 127))
painter.drawPixmap(self.p1.x(), self.p1.y(), pm_box)
painter.drawRect(self.p1.x(), self.p1.y(),
self.p2.x() - self.p1.x(),
self.p2.y() - self.p1.y())
painter.drawRect(self.p1.x(), self.p1.y(), 59, 59)
painter.drawRect(self.p2.x(), self.p2.y(), -59, -59)
painter.setPen(Qt.white)
painter.drawRect(self.p1.x() + 1, self.p1.y() + 1, 57, 57)
painter.drawRect(self.p2.x() - 1, self.p2.y() - 1, -57, -57)
painter.end()
self.setPixmap(pm)
self.imageUpdated.emit()
def paintGame(painter: QPainter):
painter.fillRect(0, 0, 300, 300, Qt.white)
pen = painter.pen()
pen.setWidth(3)
painter.setPen(pen)
painter.drawLine(0, 100, 300, 100)
painter.drawLine(0, 200, 300, 200)
painter.drawLine(100, 0, 100, 300)
painter.drawLine(200, 0, 200, 300)
font = painter.font()
font.setPixelSize(80)
painter.setFont(font)
for i in range(3):
for j in range(3):
if board[i][j] != '_':
painter.drawText(i * 100, j * 100, 100, 100, Qt.AlignCenter,
board[i][j])
def showNextPiece(self):
if self.nextPieceLabel is None:
return
dx = self.nextPiece.maxX() - self.nextPiece.minX() + 1
dy = self.nextPiece.maxY() - self.nextPiece.minY() + 1
pixmap = QPixmap(dx * self.squareWidth(), dy * self.squareHeight())
painter = QPainter(pixmap)
painter.fillRect(pixmap.rect(), self.nextPieceLabel.palette().window())
for i in range(4):
x = self.nextPiece.x(i) - self.nextPiece.minX()
y = self.nextPiece.y(i) - self.nextPiece.minY()
self.drawSquare(painter, x * self.squareWidth(),
y * self.squareHeight(), self.nextPiece.shape())
painter.end()
self.nextPieceLabel.setPixmap(pixmap)
def paintEvent(self, event):
if self.image.isNull():
return
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
rect = QRect(-self.origin / self.zoom, self.size() / self.zoom)
cropped = self.image.copy(rect)
image = cropped.scaled(self.size(), Qt.KeepAspectRatio,
Qt.SmoothTransformation)
painter.drawImage(0, 0, image)
if self.pressedPoint is not None and not self.moving:
painter.setPen(QPen(QColor(255, 255, 255, 128), 3.0))
painter.drawEllipse(self.pressedPoint, self.triggerDistance,
self.triggerDistance)
if self.currentColor is not None:
painter.fillRect(0, 0, self.size().width(), 20, self.currentColor)
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.fillRect(event.rect(), QBrush(QColor(255, 255, 255, 127)))
painter.setPen(QPen(Qt.NoPen))
for i in range(1, 7):
if self.position_index == i:
painter.setBrush(QBrush(QColor(255, 165, 0)))
else:
painter.setBrush(QBrush(QColor(127, 127, 127)))
painter.drawEllipse(
self.width() / 2 + 30 * numpy.cos(2 * numpy.pi * i / 6.0) - 10,
self.height() / 2 + 30 * numpy.sin(2 * numpy.pi * i / 6.0) -
10, 20, 20)
time.sleep(0.005)
painter.end()
def paint(self,
painter: QtGui.QPainter,
option: 'QStyleOptionGraphicsItem',
widget: QWidget = None):
print(option.levelOfDetailFromTransform(painter.worldTransform()))
painter.save()
pen = QPen(Qt.red)
pen.setWidth(0)
painter.setPen(pen)
brush = pen.brush()
for i in range(200 - 1):
height = data['high'][i] - data['low'][i]
painter.fillRect(
QRectF(i * 3, data['high'][i] - data['high'].min(), 1, height),
brush)
painter.fillRect(QRectF(100, 100, 100, -100), Qt.blue)
painter.restore()
