def paint(self, painter, option, widget):
"""Draws the import statement"""
del option # unused argument
del widget # unused argument
settings = self.canvas.settings
painter.setPen(self.getPainterPen(self.isSelected(), self.borderColor))
painter.setBrush(QBrush(self.bgColor))
painter.drawRect(self.baseX + settings.hCellPadding,
self.baseY + settings.vCellPadding,
self.minWidth - 2 * settings.hCellPadding,
self.minHeight - 2 * settings.vCellPadding)
painter.drawLine(
self.baseX + settings.hCellPadding + self.iconItem.iconWidth() +
2 * settings.hTextPadding, self.baseY + settings.vCellPadding,
self.baseX + settings.hCellPadding + self.iconItem.iconWidth() +
2 * settings.hTextPadding,
self.baseY + self.minHeight - settings.vCellPadding)
# Draw the text in the rectangle
pen = QPen(self.fgColor)
painter.setFont(settings.monoFont)
painter.setPen(pen)
textRectWidth = self.minWidth - 2 * settings.hCellPadding - \
4 * settings.hTextPadding - self.iconItem.iconWidth()
textShift = (textRectWidth - self.textRect.width()) / 2
painter.drawText(
self.baseX + settings.hCellPadding + self.iconItem.iconWidth() +
3 * settings.hTextPadding + textShift,
self.baseY + settings.vCellPadding + settings.vTextPadding,
self.textRect.width(), self.textRect.height(), Qt.AlignLeft,
self.text)
def paint(self, painter, option, widget):
"""Draws the leading comment"""
settings = self.canvas.settings
self.setPen(
self.getPainterPen(self.isSelected(), settings.commentBorderColor))
self.setBrush(QBrush(settings.commentBGColor))
# Bottom adjustment
yShift = self.height - self.minHeight
baseY = self.baseY + yShift
# Hide the dotted outline
itemOption = QStyleOptionGraphicsItem(option)
if itemOption.state & QStyle.State_Selected != 0:
itemOption.state = itemOption.state & ~QStyle.State_Selected
QGraphicsPathItem.paint(self, painter, itemOption, widget)
# Draw the text in the rectangle
pen = QPen(settings.commentFGColor)
painter.setFont(settings.monoFont)
painter.setPen(pen)
painter.drawText(
self._leftEdge + settings.hCellPadding + settings.hTextPadding,
baseY + settings.vCellPadding + settings.vTextPadding,
self.textRect.width(), self.textRect.height(), Qt.AlignLeft,
self.text)
def paint(self, painter, option, widget):
"""Draws the code block"""
del option # unused argument
del widget # unused argument
settings = self.canvas.settings
painter.setPen(self.getPainterPen(self.isSelected(), self.borderColor))
painter.setBrush(QBrush(self.bgColor))
rectWidth = self.minWidth - 2 * settings.hCellPadding
rectHeight = self.minHeight - 2 * settings.vCellPadding
yPos = self.baseY + settings.vCellPadding
if self.aboveBadges.hasAny():
badgeShift = self.aboveBadges.height + settings.badgeToScopeVPadding
yPos += badgeShift
rectHeight -= badgeShift
painter.drawRect(self.baseX + settings.hCellPadding,
yPos, rectWidth, rectHeight)
# Draw the text in the rectangle
pen = QPen(self.fgColor)
painter.setFont(settings.monoFont)
painter.setPen(pen)
textWidth = self.textRect.width() + 2 * settings.hTextPadding
textShift = (rectWidth - textWidth) / 2
painter.drawText(
self.baseX + settings.hCellPadding +
settings.hTextPadding + textShift,
yPos + settings.vTextPadding,
self.textRect.width(), self.textRect.height(),
Qt.AlignLeft, self.text)
def paint(self, painter, option, widget):
"""Draws the collapsed group"""
del option # unused argument
del widget # unused argument
settings = self.canvas.settings
# Group rectangle
if self.isSelected():
selectPen = QPen(settings.selectColor)
selectPen.setWidth(settings.selectPenWidth)
selectPen.setJoinStyle(Qt.RoundJoin)
painter.setPen(selectPen)
else:
pen = QPen(self.__borderColor)
if self.highlight:
pen.setStyle(Qt.SolidLine)
else:
pen.setStyle(Qt.DotLine)
pen.setWidth(1)
painter.setPen(pen)
brush = QBrush(self.__bgColor)
painter.setBrush(brush)
fullWidth = self.groupWidth + 2 * settings.openGroupHSpacer
fullHeight = self.groupHeight + 2 * settings.openGroupVSpacer
painter.drawRoundedRect(self.baseX + settings.openGroupHSpacer,
self.baseY + settings.openGroupVSpacer,
fullWidth, fullHeight,
settings.openGroupVSpacer,
settings.openGroupVSpacer)
def __paintDeclaration(self, painter):
"""Paints the scope header"""
s = self.canvas.settings
painter.setBrush(QBrush(self.bgColor))
pen = QPen(self.fgColor)
painter.setFont(s.monoFont)
painter.setPen(pen)
canvasLeft = self.baseX - s.scopeRectRadius
canvasTop = self.baseY - s.scopeRectRadius
textHeight = self.textRect.height()
yShift = 0
if hasattr(self.ref, 'sideComment'):
yShift = s.vTextPadding
painter.drawText(canvasLeft + s.hHeaderPadding,
canvasTop + s.vHeaderPadding + yShift,
self.textRect.width(), textHeight, Qt.AlignLeft,
self.text)
pen = QPen(self.borderColor)
pen.setWidth(s.boxLineWidth)
painter.setPen(pen)
# If the scope is selected then the line may need to be shorter
# to avoid covering the outline
row = self.addr[1] - 1
column = self.addr[0] - 1
correction = 0.0
if self.canvas.cells[row][column].isSelected():
correction = s.selectPenWidth - 1
painter.drawLine(
canvasLeft + correction, self.baseY + self.height, canvasLeft +
self.canvas.minWidth - 2 * s.hCellPadding - correction,
self.baseY + self.height)
def paint(self, painter, option, widget):
"""Draws the independent comment"""
del option # unused argument
del widget # unused argument
settings = self.canvas.settings
painter.setPen(self.getPainterPen(self.isSelected(), self.borderColor))
painter.setBrush(QBrush(self.bgColor))
rectWidth = self.minWidth - 2 * settings.hCellPadding
rectHeight = self.minHeight - 2 * settings.vCellPadding
painter.drawRoundedRect(self.baseX + settings.hCellPadding,
self.baseY + settings.vCellPadding,
rectWidth, rectHeight, 0, 0)
if self.text:
# Draw the text in the rectangle
font = QFont(settings.monoFont)
font.setItalic(True)
painter.setFont(font)
pen = QPen(self.fgColor)
painter.setPen(pen)
painter.drawText(
self._leftEdge + settings.hCellPadding +
settings.hDocLinkPadding + self.iconItem.iconWidth() +
settings.hDocLinkPadding,
self.baseY + settings.vCellPadding + settings.vDocLinkPadding,
self.textRect.width(), self.textRect.height(),
Qt.AlignLeft, self.text)
def paint(self, painter, option, widget):
"""Draws the code block"""
del option
del widget
baseX = (self.__viewWidth - self.__rectWidth) / 2
baseY = (self.__viewHeight - self.__rectHeight) / 2
if self.__borderColor is None:
pen = QPen(self.__bgColor)
else:
pen = QPen(self.__borderColor)
painter.setPen(pen)
brush = QBrush(self.__bgColor)
painter.setBrush(brush)
painter.drawRect(baseX, baseY, self.__rectWidth, self.__rectHeight)
# Draw the text in the rectangle
pen = QPen(self.__fgColor)
painter.setFont(self.__settings.monoFont)
painter.setPen(pen)
textWidth = self.__textRect.width() + 2 * self.__settings.hTextPadding
textShift = (self.__rectWidth - textWidth) / 2
painter.drawText(baseX + self.__settings.hTextPadding + textShift,
baseY + self.__settings.vTextPadding,
self.__textRect.width(), self.__textRect.height(),
Qt.AlignLeft, 'Sample')
def paint(self, painter, option, widget):
"""Paints the rubber band"""
pen = QPen(self.__settings.rubberBandBorderColor)
painter.setPen(pen)
brush = QBrush(self.__settings.rubberBandFGColor)
painter.setBrush(brush)
painter.drawRect(self.__x, self.__y, self.__width, self.__height)
def paint(self, painter, option, widget):
"""Draws the import statement"""
del option # unused argument
del widget # unused argument
settings = self.canvas.settings
painter.setPen(self.getPainterPen(self.isSelected(), self.borderColor))
painter.setBrush(QBrush(self.bgColor))
takenByBadges = self.aboveBadges.height + settings.badgeToScopeVPadding
yPos = self.baseY + settings.vCellPadding + takenByBadges
xPos = self.baseX + settings.hCellPadding
rectWidth = self.minWidth - 2 * settings.hCellPadding
rectHeight = self.minHeight - 2 * settings.vCellPadding - takenByBadges
painter.drawRoundedRect(xPos, yPos, rectWidth, rectHeight,
settings.decorRectRadius,
settings.decorRectRadius)
# Draw the text in the rectangle
pen = QPen(self.fgColor)
painter.setFont(settings.monoFont)
painter.setPen(pen)
painter.drawText(
xPos + settings.hTextPadding,
yPos + settings.vTextPadding,
self.textRect.width(), self.textRect.height(),
Qt.AlignLeft, self.text)
def __paintComment(self, painter):
"""Paints the side comment"""
s = self.canvas.settings
painter.setPen(
self.getPainterPen(self.isSelected(), s.commentBorderColor))
painter.setBrush(QBrush(s.commentBGColor))
canvasTop = self.baseY - s.scopeRectRadius
# s.vHeaderPadding below is used intentionally: to have the same
# spacing on top, bottom and right for the comment box
movedBaseX = self.canvas.baseX + self.canvas.minWidth - \
self.width - s.scopeRectRadius - s.vHeaderPadding
if s.hidecomments:
painter.drawRoundedRect(
movedBaseX + s.hHeaderPadding, canvasTop + s.vHeaderPadding,
self.iconItem.iconWidth() + 2 * s.hHiddenCommentPadding,
self.iconItem.iconHeight() + 2 * s.vHiddenCommentPadding,
s.hiddenCommentRectRadius, s.hiddenCommentRectRadius)
else:
painter.drawPath(self.__sideCommentPath)
pen = QPen(s.commentFGColor)
painter.setFont(s.monoFont)
painter.setPen(pen)
painter.drawText(movedBaseX + s.hHeaderPadding + s.hTextPadding,
canvasTop + s.vHeaderPadding + s.vTextPadding,
self.textRect.width(), self.textRect.height(),
Qt.AlignLeft, self.text)
def paint(self, painter, option, widget):
"""Draws the code block"""
del option # unused argument
del widget # unused argument
settings = self.canvas.settings
painter.setPen(self.getPainterPen(self.isSelected(), self.borderColor))
painter.setBrush(QBrush(self.bgColor))
painter.drawPolygon(QPointF(self.x1,
self.y1), QPointF(self.x2, self.y2),
QPointF(self.x3,
self.y3), QPointF(self.x4, self.y4),
QPointF(self.x5, self.y5),
QPointF(self.x6, self.y6))
# Draw the text in the rectangle
pen = QPen(self.fgColor)
painter.setPen(pen)
painter.setFont(settings.monoFont)
availWidth = self.x3 - self.x2
textWidth = self.textRect.width() + 2 * settings.hTextPadding
textShift = (availWidth - textWidth) / 2
painter.drawText(
self.x2 + settings.hTextPadding + textShift,
self.baseY + settings.vCellPadding + settings.vTextPadding,
self.textRect.width(), self.textRect.height(),
Qt.AlignLeft | Qt.AlignVCenter, self.text)
def paint(self, painter, option, widget):
"""Draws the independent comment"""
settings = self.canvas.settings
brush = QBrush(settings.commentBGColor)
self.setBrush(brush)
if self.isSelected():
selectPen = QPen(settings.selectColor)
selectPen.setWidth(settings.selectPenWidth)
selectPen.setJoinStyle(Qt.RoundJoin)
self.setPen(selectPen)
else:
pen = QPen(settings.commentLineColor)
pen.setWidth(settings.commentLineWidth)
pen.setJoinStyle(Qt.RoundJoin)
self.setPen(pen)
# Hide the dotted outline
itemOption = QStyleOptionGraphicsItem(option)
if itemOption.state & QStyle.State_Selected != 0:
itemOption.state = itemOption.state & ~QStyle.State_Selected
QGraphicsPathItem.paint(self, painter, itemOption, widget)
# Draw the text in the rectangle
pen = QPen(settings.commentFGColor)
painter.setFont(settings.monoFont)
painter.setPen(pen)
painter.drawText(
self.__leftEdge + settings.hCellPadding + self.__hTextPadding,
self.baseY + settings.vCellPadding + self.__vTextPadding,
self.__textRect.width(), self.__textRect.height(),
Qt.AlignLeft, self.__getText())
def paint(self, painter, option, widget):
"""Paints the text item"""
color = self.__settings.lineColor
if self.color:
color = self.color
self.setBrush(QBrush(color))
QGraphicsSimpleTextItem.paint(self, painter, option, widget)
def __paintTopLeft(self, painter):
"""Paints the scope rectangle"""
s = self.canvas.settings
painter.setPen(self.getPainterPen(self.isSelected(), self.borderColor))
painter.setBrush(QBrush(self.bgColor))
yPos = self.baseY + s.vCellPadding
height = self.canvas.minHeight - 2 * s.vCellPadding
if self.aboveBadges.hasAny():
badgeShift = self.aboveBadges.height + s.badgeToScopeVPadding
yPos += badgeShift
height -= badgeShift
if self.kind in [CellElement.FOR_SCOPE, CellElement.WHILE_SCOPE]:
cellBelow = self.canvas.cells[self.addr[1] + 1][self.addr[0]]
halfDeclHeight = (cellBelow.height + s.scopeRectRadius) / 2
yPos += halfDeclHeight
height -= halfDeclHeight
painter.drawRoundedRect(self.baseX + s.hCellPadding, yPos,
self.canvas.minWidth - 2 * s.hCellPadding,
height, s.scopeRectRadius, s.scopeRectRadius)
if self.kind in [CellElement.FOR_SCOPE, CellElement.WHILE_SCOPE]:
# Brush
if self.kind == CellElement.FOR_SCOPE:
painter.setBrush(QBrush(s.forScopeHeaderBGColor))
else:
painter.setBrush(QBrush(s.whileScopeHeaderBGColor))
# Pen, if not selected
if not self.isSelected():
if self.kind == CellElement.FOR_SCOPE:
pen = QPen(QColor(s.forScopeHeaderBorderColor))
pen.setWidth(s.forScopeHeaderPenWidth)
else:
pen = QPen(QColor(s.whileScopeHeaderBorderColor))
pen.setWidth(s.whileScopeHeaderPenWidth)
painter.setPen(pen)
painter.drawPolygon(QPointF(self.x1, self.y1),
QPointF(self.x2, self.y2),
QPointF(self.x3, self.y3),
QPointF(self.x4, self.y4),
QPointF(self.x5, self.y5),
QPointF(self.x6, self.y6))
def __paintDocstring(self, painter):
"""Paints the docstring"""
s = self.canvas.settings
painter.setBrush(QBrush(self.bgColor))
canvasLeft = self.baseX - s.scopeRectRadius
if self.isSelected():
selectPen = QPen(s.selectColor)
selectPen.setWidth(s.selectPenWidth)
selectPen.setJoinStyle(Qt.RoundJoin)
painter.setPen(selectPen)
painter.drawRect(canvasLeft, self.baseY,
self.canvas.minWidth - 2 * s.hCellPadding,
self.height)
else:
# If the scope is selected then the line may need to be shorter
# to avoid covering the outline
row = self.addr[1] - 2
column = self.addr[0] - 1
correction = 0.0
if self.canvas.cells[row][column].isSelected():
correction = s.selectPenWidth - 1
# The background could also be custom
pen = QPen(self.bgColor)
pen.setWidth(s.boxLineWidth)
pen.setJoinStyle(Qt.MiterJoin)
painter.setPen(pen)
dsCorr = float(s.boxLineWidth)
if self.canvas.cells[row][column].isSelected():
dsCorr = float(s.selectPenWidth) / 2.0 + \
float(s.boxLineWidth) / 2.0
painter.drawRect(
float(canvasLeft) + dsCorr, self.baseY + s.boxLineWidth,
float(self.canvas.minWidth) - 2.0 * float(s.hCellPadding) -
2.0 * dsCorr, self.height - 2 * s.boxLineWidth)
pen = QPen(self.borderColor)
pen.setWidth(s.boxLineWidth)
painter.setPen(pen)
painter.drawLine(
canvasLeft + correction, self.baseY + self.height, canvasLeft +
self.canvas.minWidth - 2 * s.hCellPadding - correction,
self.baseY + self.height)
if not s.hidedocstrings:
pen = QPen(self.fgColor)
painter.setFont(s.monoFont)
painter.setPen(pen)
painter.drawText(canvasLeft + s.hHeaderPadding,
self.baseY + s.vHeaderPadding,
self.canvas.width - 2 * s.hHeaderPadding,
self.height - 2 * s.vHeaderPadding, Qt.AlignLeft,
self.text)
def __paintTopLeft(self, painter):
"""Paints the scope rectangle"""
s = self.canvas.settings
painter.setPen(self.getPainterPen(self.isSelected(), self.borderColor))
painter.setBrush(QBrush(self.bgColor))
painter.drawRoundedRect(self.baseX + s.hCellPadding,
self.baseY + s.vCellPadding,
self.canvas.minWidth - 2 * s.hCellPadding,
self.canvas.minHeight - 2 * s.vCellPadding,
s.scopeRectRadius, s.scopeRectRadius)
def paint(self, painter, option, widget):
"""Draws the collapsed group"""
del option # unused argument
del widget # unused argument
settings = self.canvas.settings
# Outer rectangle
rectWidth = self.minWidth - 2 * settings.hCellPadding
rectHeight = self.minHeight - 2 * settings.vCellPadding
if self.isSelected():
selectPen = QPen(settings.selectColor)
selectPen.setWidth(settings.selectPenWidth)
selectPen.setJoinStyle(Qt.RoundJoin)
painter.setPen(selectPen)
else:
pen = QPen(self.__borderColor)
pen.setStyle(Qt.DashLine)
pen.setWidth(1)
painter.setPen(pen)
brush = QBrush(self.__bgColor)
painter.setBrush(brush)
painter.drawRect(self.baseX + settings.hCellPadding,
self.baseY + settings.vCellPadding,
rectWidth, rectHeight)
# Inner rectangle
rectWidth -= 2 * settings.collapsedOutlineWidth
rectHeight -= 2 * settings.collapsedOutlineWidth
pen = QPen(self.__borderColor)
pen.setStyle(Qt.DashLine)
pen.setWidth(1)
painter.setPen(pen)
painter.drawRect(self.baseX + settings.hCellPadding +
settings.collapsedOutlineWidth,
self.baseY + settings.vCellPadding +
settings.collapsedOutlineWidth,
rectWidth, rectHeight)
# Draw the text in the rectangle
pen = QPen(self.__fgColor)
painter.setFont(settings.monoFont)
painter.setPen(pen)
textWidth = self.__textRect.width() + 2 * settings.hTextPadding
textShift = (rectWidth - textWidth) / 2
painter.drawText(
self.baseX + settings.hCellPadding +
settings.hTextPadding + settings.collapsedOutlineWidth +
textShift,
self.baseY + settings.vCellPadding + settings.vTextPadding +
settings.collapsedOutlineWidth,
self.__textRect.width(), self.__textRect.height(),
Qt.AlignLeft, self._getText())
def paint(self, painter, option, widget):
"""Draws the independent comment"""
settings = self.canvas.settings
painter.setPen(
self.getPainterPen(self.isSelected(), settings.docLinkBorderColor))
painter.setBrush(QBrush(self.bgColor))
# xPos matches the connector (which could be drawn in any direction)
xPos = max(self.connector.getFirstPoint()[0],
self.connector.getLastPoint()[0])
painter.drawRoundedRect(xPos, self.baseY + settings.vCellPadding,
self.badgeWidth, self.badgeHeight,
settings.badgeRadius, settings.badgeRadius)
def __markItem(item):
"""Marks a single item modified"""
brush = QBrush(QColor(255, 227, 227))
item.setBackground(0, brush)
item.setBackground(1, brush)
item.setBackground(2, brush)
childIndex = item.childCount() - 1
while childIndex >= 0:
childItem = item.child(childIndex)
childItem.setModified(True)
if searchTooltip.item == childItem:
searchTooltip.setModified(True)
childIndex -= 1
def paint(self, painter, option, widget):
"""Paints the control"""
settings = self.ref.canvas.settings
pen = QPen(settings.groupControlBorderColor)
pen.setStyle(Qt.SolidLine)
pen.setWidth(1)
painter.setPen(pen)
brush = QBrush(settings.groupControlBGColor)
painter.setBrush(brush)
painter.drawRoundedRect(self.x(), self.y(), self.__width,
self.__height, 1, 1)
def paint(self, painter, option, widget):
"""Draws the code block"""
del option # unused argument
del widget # unused argument
settings = self.canvas.settings
painter.setPen(self.getPainterPen(self.isSelected(), self.borderColor))
painter.setBrush(QBrush(self.bgColor))
takenByBadges = 0
if self.aboveBadges.hasAny():
takenByBadges = self.aboveBadges.height + settings.badgeToScopeVPadding
dHalf = int(self.__diamondHeight / 2.0)
dx1 = self.baseX + settings.hCellPadding
dy1 = self.baseY + takenByBadges + int((self.minHeight - takenByBadges)/2)
dx2 = dx1 + settings.ifWidth
dy2 = dy1 - dHalf
dx3 = dx1 + self.__diamondWidth - settings.ifWidth
dy3 = dy2
dx4 = dx3 + settings.ifWidth
dy4 = dy1
dx5 = dx3
dy5 = dy2 + 2 * dHalf
dx6 = dx2
dy6 = dy5
painter.drawPolygon(QPointF(dx1, dy1), QPointF(dx2, dy2),
QPointF(dx3, dy3), QPointF(dx4, dy4),
QPointF(dx5, dy5), QPointF(dx6, dy6))
painter.drawRect(dx4 + 1, self.baseY + settings.vCellPadding + takenByBadges,
self.minWidth - 2 * settings.hCellPadding -
self.__diamondWidth,
self.minHeight - 2 * settings.vCellPadding - takenByBadges)
# Draw the text in the rectangle
pen = QPen(self.fgColor)
painter.setFont(settings.monoFont)
painter.setPen(pen)
availWidth = \
self.minWidth - 2 * settings.hCellPadding - self.__diamondWidth
textWidth = self.textRect.width() + 2 * settings.hTextPadding
textShift = (availWidth - textWidth) / 2
painter.drawText(
dx4 + settings.hTextPadding + textShift,
self.baseY + settings.vCellPadding + settings.vTextPadding + takenByBadges,
self.textRect.width(), self.textRect.height(),
Qt.AlignLeft, self.text)
def paintBadgeRectangle(self, painter, isSelected, borderColor, bgColor):
"""Draws the badge filled rectange"""
s = self.ref.canvas.settings
if isSelected:
pen = QPen(s.selectColor)
pen.setWidth(s.selectPenWidth)
else:
pen = QPen(borderColor)
pen.setWidth(s.badgeLineWidth)
pen.setJoinStyle(Qt.RoundJoin)
painter.setPen(pen)
painter.setBrush(QBrush(bgColor))
painter.drawRoundedRect(self.x(), self.y(), self.width, self.height,
s.badgeRadius, s.badgeRadius)
def paintCell(self, painter, bgColor, borderColor, option, widget):
"""Paints the comment"""
del option
del widget
settings = self.canvas.settings
painter.setPen(self.getPainterPen(self.isSelected(), borderColor))
painter.setBrush(QBrush(bgColor))
# xPos matches the connector (which could be drawn in any direction)
xPos = max(self.connector.getFirstPoint()[0],
self.connector.getFirstPoint()[0])
painter.drawRoundedRect(xPos, self.baseY + settings.vCellPadding,
self.rectWidth, self.rectHeight,
self.rectRadius, self.rectRadius)
def __paintDeclaration(self, painter):
"""Paints the scope header"""
s = self.canvas.settings
canvasLeft = self.baseX - s.scopeRectRadius
canvasTop = self.baseY - s.scopeRectRadius
row = self.addr[1] - 1
column = self.addr[0] - 1
topLeftCell = self.canvas.cells[row][column]
if self.kind not in [CellElement.FOR_SCOPE, CellElement.WHILE_SCOPE]:
painter.setBrush(QBrush(self.bgColor))
pen = QPen(self.borderColor)
pen.setWidth(s.boxLineWidth)
painter.setPen(pen)
# If the scope is selected then the line may need to be shorter
# to avoid covering the outline
correction = 0.0
if topLeftCell.isSelected():
correction = s.selectPenWidth - 1
painter.drawLine(
canvasLeft + correction, self.baseY + self.height, canvasLeft +
self.canvas.minWidth - 2 * s.hCellPadding - correction,
self.baseY + self.height)
pen = QPen(self.fgColor)
painter.setFont(s.monoFont)
painter.setPen(pen)
if self.kind in [CellElement.FOR_SCOPE, CellElement.WHILE_SCOPE]:
availWidth = topLeftCell.x3 - topLeftCell.x2
textWidth = self.textRect.width() + 2 * s.hTextPadding
textShift = (availWidth - textWidth) / 2
painter.drawText(topLeftCell.x2 + s.hTextPadding + textShift,
canvasTop + s.vHeaderPadding,
self.textRect.width(), self.textRect.height(),
Qt.AlignLeft | Qt.AlignVCenter, self.text)
else:
painter.drawText(canvasLeft + s.hHeaderPadding,
canvasTop + s.vHeaderPadding,
self.textRect.width(), self.textRect.height(),
Qt.AlignLeft, self.text)
def paint(self, painter, option, widget):
"""Draws the sys.exit call"""
del option # unused argument
del widget # unused argument
settings = self.canvas.settings
painter.setPen(self.getPainterPen(self.isSelected(), self.borderColor))
painter.setBrush(QBrush(self.bgColor))
rectWidth = self.minWidth - 2 * settings.hCellPadding
rectHeight = self.minHeight - 2 * settings.vCellPadding
yPos = self.baseY + settings.vCellPadding
xPos = self.baseX + settings.hCellPadding
if self.aboveBadges.hasAny():
badgeShift = self.aboveBadges.height + settings.badgeToScopeVPadding
yPos += badgeShift
rectHeight -= badgeShift
painter.drawRoundedRect(
xPos, yPos, rectWidth, rectHeight,
settings.returnRectRadius, settings.returnRectRadius)
lineXPos = xPos + self.iconItem.iconWidth() + \
2 * settings.hTextPadding
painter.drawLine(lineXPos, yPos, lineXPos, yPos + rectHeight)
# Draw the text in the rectangle
pen = QPen(self.fgColor)
painter.setFont(settings.monoFont)
painter.setPen(pen)
availWidth = \
self.minWidth - 2 * settings.hCellPadding - \
self.iconItem.iconWidth() - \
2 * settings.hTextPadding - \
settings.hTextPadding - settings.returnRectRadius
textShift = (availWidth - self.textRect.width()) / 2
painter.drawText(
xPos + self.iconItem.iconWidth() +
3 * settings.hTextPadding + textShift,
yPos + settings.vTextPadding,
self.textRect.width(), self.textRect.height(),
Qt.AlignLeft, self.text)
def paintCell(self, painter, rectRadius):
"""Draws the cell"""
settings = self.canvas.settings
painter.setPen(self.getPainterPen(self.isSelected(), self.borderColor))
painter.setBrush(QBrush(self.bgColor))
painter.drawRoundedRect(self.xPos, self.yPos, self.rectWidth,
self.rectHeight, rectRadius, rectRadius)
# Draw the text in the rectangle
pen = QPen(self.fgColor)
painter.setFont(settings.monoFont)
painter.setPen(pen)
hShift = (self.rectWidth - self.textRect.width()) / 2
vShift = (self.rectHeight - self.textRect.height()) / 2
painter.drawText(self.xPos + hShift, self.yPos + vShift,
self.textRect.width(), self.textRect.height(),
Qt.AlignLeft, self.text)
def paint(self, painter, option, widget):
"""Draws the leading comment"""
settings = self.canvas.settings
# Bottom adjustment
yShift = self.height - self.minHeight
baseY = self.baseY + yShift
# Left adjustments
shift = self.hShift * 2 * settings.openGroupHSpacer
self._leftEdge += shift
brush = QBrush(settings.commentBGColor)
self.setBrush(brush)
if self.isSelected():
selectPen = QPen(settings.selectColor)
selectPen.setWidth(settings.selectPenWidth)
selectPen.setJoinStyle(Qt.RoundJoin)
self.setPen(selectPen)
else:
pen = QPen(settings.commentLineColor)
pen.setWidth(settings.commentLineWidth)
pen.setJoinStyle(Qt.RoundJoin)
self.setPen(pen)
# Hide the dotted outline
itemOption = QStyleOptionGraphicsItem(option)
if itemOption.state & QStyle.State_Selected != 0:
itemOption.state = itemOption.state & ~QStyle.State_Selected
QGraphicsPathItem.paint(self, painter, itemOption, widget)
# Draw the text in the rectangle
pen = QPen(settings.commentFGColor)
painter.setFont(settings.monoFont)
painter.setPen(pen)
painter.drawText(
self._leftEdge + settings.hCellPadding + self._hTextPadding,
baseY + settings.vCellPadding + self._vTextPadding,
self._textRect.width(), self._textRect.height(), Qt.AlignLeft,
self.__getText())
self._leftEdge -= shift
def paint(self, painter, option, widget):
"""Paints the badge item"""
s = self.ref.canvas.settings
if self.__needRect:
pen = QPen(self.__frameColor)
pen.setWidth(s.badgeLineWidth)
painter.setPen(pen)
brush = QBrush(self.__bgColor)
painter.setBrush(brush)
painter.drawRoundedRect(self.x(), self.y(), self.__width,
self.__height, self.__radius,
self.__radius)
pen = QPen(self.__fgColor)
painter.setPen(pen)
painter.setFont(self.__font)
painter.drawText(self.x() + self.__hSpacing,
self.y() + self.__vSpacing, self.__textRect.width(),
self.__textRect.height(), Qt.AlignLeft, self.__text)
def paint(self, painter, option, widget):
"""Draws the collapsed group"""
del option # unused argument
del widget # unused argument
settings = self.canvas.settings
pen = self.getPainterPen(self.isSelected(), self.borderColor)
if not self.highlight and not self.isSelected():
pen.setStyle(Qt.DotLine)
painter.setPen(pen)
painter.setBrush(QBrush(self.bgColor))
# Group rectangle
fullWidth = self.groupWidth + 2 * settings.openGroupHSpacer
fullHeight = self.groupHeight + 2 * settings.openGroupVSpacer
painter.drawRoundedRect(self.baseX + settings.openGroupHSpacer,
self.baseY + settings.openGroupVSpacer,
fullWidth, fullHeight,
settings.openGroupVSpacer,
settings.openGroupVSpacer)
def paint(self, painter, option, widget):
"""Paints the badge item"""
del option
del widget
s = self.ref.canvas.settings
if self.__needRect:
pen = QPen(self.__frameColor)
pen.setWidth(s.badgeLineWidth)
painter.setPen(pen)
painter.setBrush(QBrush(self.__bgColor))
painter.drawRoundedRect(self.x(), self.y(), self.width,
self.height, s.badgeRadius, s.badgeRadius)
pen = QPen(self.__fgColor)
painter.setPen(pen)
painter.setFont(s.badgeFont)
painter.drawText(self.x() + s.badgeHSpacing,
self.y() + s.badgeVSpacing, self.__textRect.width(),
self.__textRect.height(), Qt.AlignCenter, self.__text)