def paintEvent(self, event):
"""Qt Override.
Include a validation icon to the left of the line edit.
"""
super(IconLineEdit, self).paintEvent(event)
painter = QPainter(self)
rect = self.geometry()
space = int((rect.height())/6)
h = rect.height() - space
w = rect.width() - h
if self._icon_visible:
if self._status and self._status_set:
pixmap = self._set_icon.pixmap(h, h)
elif self._status:
pixmap = self._valid_icon.pixmap(h, h)
else:
pixmap = self._invalid_icon.pixmap(h, h)
painter.drawPixmap(w, space, pixmap)
application_style = QApplication.style().objectName()
if self._application_style != application_style:
self._application_style = application_style
self._refresh()
# Small hack to gurantee correct padding on Spyder start
if self._paint_count < 5:
self._paint_count += 1
self._refresh()
def paintEvent(self, event):
"""Fills the panel background using QPalette."""
if self.isVisible() and self.position != self.Position.FLOATING:
# fill background
self._background_brush = QBrush(QColor(
self.editor.sideareas_color))
self._foreground_pen = QPen(QColor(
self.palette().windowText().color()))
painter = QPainter(self)
painter.fillRect(event.rect(), self._background_brush)
def paintEvent(self, event):
""" """
self.build_paths()
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.fillPath(self.round_rect_path, self.color_back)
painter.fillPath(self.top_rect_path, self.color_top)
painter.strokePath(self.round_rect_path, QPen(Qt.gray, 1))
def paintEvent(self, event):
"""Override Qt method."""
painter = QPainter(self)
color = QColor(self.color)
color.setAlphaF(.5)
painter.setPen(color)
offset = self.editor.document().documentMargin() + \
self.editor.contentOffset().x()
for _, line_number, block in self.editor.visible_blocks:
indentation = TextBlockHelper.get_fold_lvl(block)
ref_lvl = indentation
block = block.next()
last_line = block.blockNumber()
lvl = TextBlockHelper.get_fold_lvl(block)
if ref_lvl == lvl: # for zone set programmatically such as imports
# in pyqode.python
ref_lvl -= 1
while (block.isValid() and
TextBlockHelper.get_fold_lvl(block) > ref_lvl):
last_line = block.blockNumber()
block = block.next()
end_of_sub_fold = block
if last_line:
block = block.document().findBlockByNumber(last_line)
while ((block.blockNumber()) and (block.text().strip() == ''
or block.text().strip().startswith('#'))):
block = block.previous()
last_line = block.blockNumber()
block = self.editor.document().findBlockByNumber(line_number)
top = int(self.editor.blockBoundingGeometry(block).translated(
self.editor.contentOffset()).top())
bottom = top + int(self.editor.blockBoundingRect(block).height())
indentation = TextBlockHelper.get_fold_lvl(block)
for i in range(1, indentation):
if (line_number > last_line and
TextBlockHelper.get_fold_lvl(end_of_sub_fold) <= i):
continue
else:
x = self.editor.fontMetrics().width(i * self.i_width *
'9') + offset
painter.drawLine(x, top, x, bottom)
def paintEvent(self, event):
"""Override Qt method."""
painter = QPainter(self)
color = QColor(self.color)
color.setAlphaF(.5)
painter.setPen(color)
for top, line_number, block in self.editor.visible_blocks:
bottom = top + int(self.editor.blockBoundingRect(block).height())
indentation = TextBlockHelper.get_fold_lvl(block)
for i in range(1, indentation):
x = self.editor.fontMetrics().width(i * self.i_width * '9')
painter.drawLine(x, top, x, bottom)
def __init__(self, parent=None, circle=False):
super(PyDMBitIndicator, self).__init__(parent)
self.setAutoFillBackground(True)
self.circle = circle
self._painter = QPainter()
self._brush = QBrush(Qt.SolidPattern)
self._pen = QPen(Qt.SolidLine)
def paintEvent(self, event):
"""Qt method override to paint a custom image on the Widget."""
super(FigureCanvas, self).paintEvent(event)
# Prepare the rect on which the image is going to be painted :
fw = self.frameWidth()
rect = QRect(0 + fw, 0 + fw,
self.size().width() - 2 * fw,
self.size().height() - 2 * fw)
if self.fig is None or self._blink_flag:
return
# Check/update the qpixmap buffer :
qpix2paint = None
for qpix in self._qpix_buffer:
if qpix.size().width() == rect.width():
qpix2paint = qpix
break
else:
if self.fmt in ['image/png', 'image/jpeg']:
qpix2paint = self._qpix_orig.scaledToWidth(
rect.width(), mode=Qt.SmoothTransformation)
elif self.fmt == 'image/svg+xml':
qpix2paint = QPixmap(svg_to_image(self.fig, rect.size()))
self._qpix_buffer.append(qpix2paint)
if qpix2paint is not None:
# Paint the image on the widget :
qp = QPainter()
qp.begin(self)
qp.drawPixmap(rect, qpix2paint)
qp.end()
def paintEvent(self, event):
"""Override Qt method"""
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
# Decoration
painter.fillPath(self.path_current, QBrush(self.color))
painter.strokePath(self.path_decoration, QPen(self.color_decoration, self.stroke_decoration))
def paintEvent(self, event):
QPushButton.paintEvent(self, event)
qp = QPainter()
qp.begin(self)
font = qp.font()
font.setPixelSize(self.font().pixelSize() * 0.6)
font.setWeight(QFont.Normal)
qp.setFont(font)
#qp.drawText(event.rect().translated(2, 2), str(self._atomic_number))
qp.end()
def __init__(self, parent=None, init_channel=None):
QWidget.__init__(self, parent)
PyDMWidget.__init__(self, init_channel=init_channel)
if 'Index' not in PyDMSymbol.RULE_PROPERTIES:
PyDMSymbol.RULE_PROPERTIES = PyDMWidget.RULE_PROPERTIES.copy()
PyDMSymbol.RULE_PROPERTIES.update(
{'Index': ['set_current_key', object]})
self.app = QApplication.instance()
self._current_key = 0
self._state_images_string = ""
self._state_images = {} # Keyed on state values (ints), values are (filename, qpixmap or qsvgrenderer) tuples.
self._aspect_ratio_mode = Qt.KeepAspectRatio
self._sizeHint = self.minimumSizeHint()
self._painter = QPainter()
def paintEvent(self, event):
"""Override Qt method.
Paint breakpoints icons.
"""
super(DebuggerPanel, self).paintEvent(event)
painter = QPainter(self)
painter.fillRect(event.rect(), self.editor.sideareas_color)
for top, line_number, block in self.editor.visible_blocks:
if self.line_number_hint == line_number:
self._draw_breakpoint_icon(top, painter, 'transparent')
if self._current_line_arrow == line_number and not self.stop:
self._draw_breakpoint_icon(top, painter, 'arrow')
data = block.userData()
if data is None or not data.breakpoint:
continue
if data.breakpoint_condition is None:
self._draw_breakpoint_icon(top, painter, 'breakpoint')
else:
self._draw_breakpoint_icon(top, painter, 'condition')
def __init__(self, parent=None):
super(QScale, self).__init__(parent)
self._value = 1
self._lower_limit = -5
self._upper_limit = 5
self.position = None # unit: pixel
self._bg_color = QColor('darkgray')
self._bg_size_rate = 0.8 # from 0 to 1
self._indicator_color = QColor('black')
self._pointer_width_rate = 0.05
self._barIndicator = False
self._num_divisions = 10
self._show_ticks = True
self._tick_pen = QPen()
self._tick_color = QColor('black')
self._tick_width = 0
self._tick_size_rate = 0.1 # from 0 to 1
self._painter = QPainter()
self._painter_rotation = None
self._painter_translation_y = None
self._painter_translation_x = None
self._painter_scale_x = None
self._flip_traslation_y = None
self._flip_scale_y = None
self._widget_width = self.width()
self._widget_height = self.height()
self._orientation = Qt.Horizontal
self._inverted_appearance = False
self._flip_scale = False
self._scale_height = 35
self._origin_at_zero = False
self._origin_position = 0
self.set_position()
class PyDMSymbol(QWidget, PyDMWidget):
"""
PyDMSymbol will render an image (symbol) for each value of a channel.
Parameters
----------
parent : QWidget
The parent widget for the Label
init_channel : str, optional
The channel to be used by the widget.
"""
def __init__(self, parent=None, init_channel=None):
QWidget.__init__(self, parent)
PyDMWidget.__init__(self, init_channel=init_channel)
if 'Index' not in PyDMSymbol.RULE_PROPERTIES:
PyDMSymbol.RULE_PROPERTIES = PyDMWidget.RULE_PROPERTIES.copy()
PyDMSymbol.RULE_PROPERTIES.update(
{'Index': ['set_current_key', object]})
self.app = QApplication.instance()
self._current_key = 0
self._state_images_string = ""
self._state_images = {} # Keyed on state values (ints), values are (filename, qpixmap or qsvgrenderer) tuples.
self._aspect_ratio_mode = Qt.KeepAspectRatio
self._sizeHint = self.minimumSizeHint()
self._painter = QPainter()
def init_for_designer(self):
"""
Method called after the constructor to tweak configurations for
when using the widget with the Qt Designer
"""
self.value = 0
self._current_key = 0
def set_current_key(self, current_key):
"""
Change the image being displayed for the one given by `current_key`.
Parameters
----------
current_key : object
The current_key parameter can be of any type as long as it matches
the type used as key for the imageFiles dictionary.
"""
if self._current_key != current_key:
self._current_key = current_key
self.update()
@Property(str)
def imageFiles(self):
"""
JSON-formatted dictionary keyed on states (integers), with filenames
of the image file to display for the state.
Returns
-------
str
"""
if not self._state_images:
return self._state_images_string
return json.dumps({str(state): val[0] for (state, val) in self._state_images.items()})
@imageFiles.setter
def imageFiles(self, new_files):
"""
JSON-formatted dictionary keyed on states (integers), with filenames
of the image file to display for the state.
Parameters
----------
new_files : str
"""
self._state_images_string = str(new_files)
try:
new_file_dict = json.loads(self._state_images_string)
except Exception:
self._state_images = {}
return
self._sizeHint = QSize(0, 0)
for (state, filename) in new_file_dict.items():
if is_pydm_app():
try:
file_path = self.app.get_path(filename)
except Exception as e:
logger.exception("Couldn't get file with path %s", filename)
file_path = filename
else:
file_path = filename
# First, lets try SVG. We have to try SVG first, otherwise
# QPixmap will happily load the SVG and turn it into a raster image.
# Really annoying: We have to try to load the file as SVG,
# and we expect it will fail often (because many images aren't SVG).
# Qt prints a warning message to stdout any time SVG loading fails.
# So we have to temporarily silence Qt warning messages here.
qInstallMessageHandler(self.qt_message_handler)
svg = QSvgRenderer()
svg.repaintNeeded.connect(self.update)
if svg.load(file_path):
self._state_images[int(state)] = (filename, svg)
self._sizeHint = self._sizeHint.expandedTo(svg.defaultSize())
qInstallMessageHandler(None)
continue
qInstallMessageHandler(None)
# SVG didn't work, lets try QPixmap
image = QPixmap(file_path)
if not image.isNull():
self._state_images[int(state)] = (filename, image)
self._sizeHint = self._sizeHint.expandedTo(image.size())
continue
# If we get this far, the file specified could not be loaded at all.
logger.error("Could not load image: {}".format(filename))
self._state_images[int(state)] = (filename, None)
@Property(Qt.AspectRatioMode)
def aspectRatioMode(self):
"""
Which aspect ratio mode to use.
Returns
-------
Qt.AspectRatioMode
"""
return self._aspect_ratio_mode
@aspectRatioMode.setter
def aspectRatioMode(self, new_mode):
"""
Which aspect ratio mode to use.
Parameters
-----------
new_mode : Qt.AspectRatioMode
"""
if new_mode != self._aspect_ratio_mode:
self._aspect_ratio_mode = new_mode
self.update()
def connection_changed(self, connected):
"""
Callback invoked when the connection state of the Channel is changed.
This callback acts on the connection state to enable/disable the widget
and also trigger the change on alarm severity to ALARM_DISCONNECTED.
Parameters
----------
connected : int
When this value is 0 the channel is disconnected, 1 otherwise.
"""
super(PyDMSymbol, self).connection_changed(connected)
self.update()
def value_changed(self, new_val):
"""
Callback invoked when the Channel value is changed.
Parameters
----------
new_val : int
The new value from the channel.
"""
super(PyDMSymbol, self).value_changed(new_val)
self._current_key = new_val
self.update()
def sizeHint(self):
"""
This property holds the recommended size for the widget.
Returns
-------
QSize
"""
return self._sizeHint
def minimumSizeHint(self):
"""
This property holds the recommended minimum size for the widget.
Returns
-------
QSize
"""
return QSize(10, 10) # This is totally arbitrary, I just want *some* visible nonzero size
def paintEvent(self, event):
"""
Paint events are sent to widgets that need to update themselves,
for instance when part of a widget is exposed because a covering
widget was moved.
At PyDMSymbol this method handles the alarm painting with parameters
from the stylesheet and draws the proper image.
Parameters
----------
event : QPaintEvent
"""
self._painter.begin(self)
opt = QStyleOption()
opt.initFrom(self)
self.style().drawPrimitive(QStyle.PE_Widget, opt, self._painter, self)
# self._painter.setRenderHint(QPainter.Antialiasing)
if self._current_key is None:
self._painter.end()
return
image_to_draw = self._state_images.get(self._current_key, (None, None))[1]
if image_to_draw is None:
self._painter.end()
return
if isinstance(image_to_draw, QPixmap):
w = float(image_to_draw.width())
h = float(image_to_draw.height())
if self._aspect_ratio_mode == Qt.IgnoreAspectRatio:
scale = (event.rect().width() / w, event.rect().height() / h)
elif self._aspect_ratio_mode == Qt.KeepAspectRatio:
sf = min(event.rect().width() / w, event.rect().height() / h)
scale = (sf, sf)
elif self._aspect_ratio_mode == Qt.KeepAspectRatioByExpanding:
sf = max(event.rect().width() / w, event.rect().height() / h)
scale = (sf, sf)
self._painter.scale(scale[0], scale[1])
self._painter.drawPixmap(event.rect().x(), event.rect().y(), image_to_draw)
elif isinstance(image_to_draw, QSvgRenderer):
draw_size = QSizeF(image_to_draw.defaultSize())
draw_size.scale(QSizeF(event.rect().size()), self._aspect_ratio_mode)
image_to_draw.render(self._painter, QRectF(0.0, 0.0, draw_size.width(), draw_size.height()))
self._painter.end()
def qt_message_handler(self, msg_type, *args):
# Intentionally suppress all qt messages. Make sure not to leave this handler installed.
pass
class PyDMBitIndicator(QWidget):
"""
A QWidget which draws a colored circle or rectangle
Parameters
----------
parent : QWidget
The parent widget for the Label
"""
def __init__(self, parent=None, circle=False):
super(PyDMBitIndicator, self).__init__(parent)
self.setAutoFillBackground(True)
self.circle = circle
self._painter = QPainter()
self._brush = QBrush(Qt.SolidPattern)
self._pen = QPen(Qt.SolidLine)
def paintEvent(self, event):
"""
Paint events are sent to widgets that need to update themselves,
for instance when part of a widget is exposed because a covering
widget was moved.
Parameters
----------
event : QPaintEvent
"""
self._painter.begin(self)
opt = QStyleOption()
opt.initFrom(self)
self.style().drawPrimitive(QStyle.PE_Widget, opt, self._painter, self)
self._painter.setRenderHint(QPainter.Antialiasing)
self._painter.setBrush(self._brush)
self._painter.setPen(self._pen)
if self.circle:
rect = event.rect()
w = rect.width()
h = rect.height()
r = min(w, h) / 2.0 - 2.0 * max(self._pen.widthF(), 1.0)
self._painter.drawEllipse(QPoint(w / 2.0, h / 2.0), r, r)
else:
self._painter.drawRect(event.rect())
self._painter.end()
def setColor(self, color):
"""
Property for the color to be used when drawing
Parameters
----------
QColor
"""
self._brush.setColor(color)
self.update()
def minimumSizeHint(self):
fm = QFontMetrics(self.font())
return QSize(fm.height(), fm.height())
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(QtCore.Qt.NoPen))
for i in range(6):
if (self.counter / 5) % 6 == i:
painter.setBrush(QBrush(QColor(127 + (self.counter % 5) * 32, 127, 127)))
else:
painter.setBrush(QBrush(QColor(127, 127, 127)))
painter.drawEllipse(
self.width() / 2 + 30 * np.cos(2 * np.pi * i / 6.0) - 10,
self.height() / 2 + 30 * np.sin(2 * np.pi * i / 6.0) - 10,
20, 20
)
painter.end()
def create_high_dpi_drop_indicator_pixmap(self, size: QSizeF,
area: DockWidgetArea,
mode: OverlayMode) -> QPixmap:
'''
Create high dpi drop indicator pixmap
Parameters
----------
size : QSizeF
area : DockWidgetArea
mode : OverlayMode
Returns
-------
value : QPixmap
'''
border_color = self.icon_color(IconColor.frame_color)
background_color = self.icon_color(IconColor.window_background_color)
window = self.public.window()
# QT version compatibility (TODO necessary for qtpy?)
device_pixel_ratio = (window.devicePixelRatioF() if hasattr(
window, 'devicePixelRatioF') else window.devicePixelRatio())
pixmap_size = QSizeF(size * device_pixel_ratio)
pm = QPixmap(pixmap_size.toSize())
pm.fill(QColor(0, 0, 0, 0))
p = QPainter(pm)
pen = p.pen()
shadow_rect = QRectF(pm.rect())
base_rect = QRectF()
base_rect.setSize(shadow_rect.size() * 0.7)
base_rect.moveCenter(shadow_rect.center())
# Fill
shadow_color = self.icon_color(IconColor.shadow_color)
if shadow_color.alpha() == 255:
shadow_color.setAlpha(64)
p.fillRect(shadow_rect, shadow_color)
# Drop area rect.
p.save()
area_rect = QRectF()
area_line = QLineF()
non_area_rect = QRectF()
if area == DockWidgetArea.top:
area_rect = QRectF(base_rect.x(), base_rect.y(), base_rect.width(),
base_rect.height() * .5)
non_area_rect = QRectF(base_rect.x(),
shadow_rect.height() * .5,
base_rect.width(),
base_rect.height() * .5)
area_line = QLineF(area_rect.bottomLeft(), area_rect.bottomRight())
elif area == DockWidgetArea.right:
area_rect = QRectF(shadow_rect.width() * .5, base_rect.y(),
base_rect.width() * .5, base_rect.height())
non_area_rect = QRectF(base_rect.x(), base_rect.y(),
base_rect.width() * .5, base_rect.height())
area_line = QLineF(area_rect.topLeft(), area_rect.bottomLeft())
elif area == DockWidgetArea.bottom:
area_rect = QRectF(base_rect.x(),
shadow_rect.height() * .5, base_rect.width(),
base_rect.height() * .5)
non_area_rect = QRectF(base_rect.x(), base_rect.y(),
base_rect.width(),
base_rect.height() * .5)
area_line = QLineF(area_rect.topLeft(), area_rect.topRight())
elif area == DockWidgetArea.left:
area_rect = QRectF(base_rect.x(), base_rect.y(),
base_rect.width() * .5, base_rect.height())
non_area_rect = QRectF(shadow_rect.width() * .5, base_rect.y(),
base_rect.width() * .5, base_rect.height())
area_line = QLineF(area_rect.topRight(), area_rect.bottomRight())
baseSize = base_rect.size()
if (OverlayMode.container == mode and area != DockWidgetArea.center):
base_rect = area_rect
p.fillRect(base_rect, background_color)
if area_rect.isValid():
pen = p.pen()
pen.setColor(border_color)
Color = self.icon_color(IconColor.overlay_color)
if Color.alpha() == 255:
Color.setAlpha(64)
p.setBrush(Color)
p.setPen(Qt.NoPen)
p.drawRect(area_rect)
pen = p.pen()
pen.setWidth(1)
pen.setColor(border_color)
pen.setStyle(Qt.DashLine)
p.setPen(pen)
p.drawLine(area_line)
p.restore()
p.save()
# Draw outer border
pen = p.pen()
pen.setColor(border_color)
pen.setWidth(1)
p.setBrush(Qt.NoBrush)
p.setPen(pen)
p.drawRect(base_rect)
# draw window title bar
p.setBrush(border_color)
frame_rect = QRectF(base_rect.topLeft(),
QSizeF(base_rect.width(),
baseSize.height() / 10))
p.drawRect(frame_rect)
p.restore()
# Draw arrow for outer container drop indicators
if (OverlayMode.container == mode and area != DockWidgetArea.center):
arrow_rect = QRectF()
arrow_rect.setSize(baseSize)
arrow_rect.setWidth(arrow_rect.width() / 4.6)
arrow_rect.setHeight(arrow_rect.height() / 2)
arrow_rect.moveCenter(QPointF(0, 0))
arrow = QPolygonF()
arrow.append(arrow_rect.topLeft())
arrow.append(QPointF(arrow_rect.right(), arrow_rect.center().y()))
arrow.append(arrow_rect.bottomLeft())
p.setPen(Qt.NoPen)
p.setBrush(self.icon_color(IconColor.arrow_color))
p.setRenderHint(QPainter.Antialiasing, True)
p.translate(non_area_rect.center().x(), non_area_rect.center().y())
if area == DockWidgetArea.top:
p.rotate(-90)
elif area == DockWidgetArea.right:
...
elif area == DockWidgetArea.bottom:
p.rotate(90)
elif area == DockWidgetArea.left:
p.rotate(180)
p.drawPolygon(arrow)
pm.setDevicePixelRatio(device_pixel_ratio)
return pm
def paintEvent(self, event):
"""Paint the colorbox.
Parameters
----------
event : qtpy.QtCore.QEvent
Event from the Qt context.
"""
painter = QPainter(self)
if self.layer._selected_color is None:
for i in range(self._height // 6):
for j in range(self._height // 6):
if (i % 2 == 0 and j % 2 == 0) or (i % 2 == 1
and j % 2 == 1):
painter.setPen(QColor(230, 230, 230))
painter.setBrush(QColor(230, 230, 230))
else:
painter.setPen(QColor(25, 25, 25))
painter.setBrush(QColor(25, 25, 25))
painter.drawRect(i * 6, j * 6, 5, 5)
else:
color = 255 * self.layer._selected_color
color = color.astype(int)
painter.setPen(QColor(*list(color)))
painter.setBrush(QColor(*list(color)))
painter.drawRect(0, 0, self._height, self._height)
def paintEvent(self, _):
painter = QPainter(self)
self.drawColorBar(painter, self.rect())
def paintEvent(self, event):
"""
Override Qt method.
Painting the scroll flag area
"""
make_flag = self.make_flag_qrect
# Fill the whole painting area
painter = QPainter(self)
painter.fillRect(event.rect(), self.editor.sideareas_color)
# Paint warnings and todos
block = self.editor.document().firstBlock()
for line_number in range(self.editor.document().blockCount() + 1):
data = block.userData()
if data:
if data.code_analysis:
# Paint the warnings
color = self.editor.warning_color
for source, code, severity, message in data.code_analysis:
error = severity == DiagnosticSeverity.ERROR
if error:
color = self.editor.error_color
break
self.set_painter(painter, color)
painter.drawRect(make_flag(line_number))
if data.todo:
# Paint the todos
self.set_painter(painter, self.editor.todo_color)
painter.drawRect(make_flag(line_number))
if data.breakpoint:
# Paint the breakpoints
self.set_painter(painter, self.editor.breakpoint_color)
painter.drawRect(make_flag(line_number))
block = block.next()
# Paint the occurrences
if self.editor.occurrences:
self.set_painter(painter, self.editor.occurrence_color)
for line_number in self.editor.occurrences:
painter.drawRect(make_flag(line_number))
# Paint the found results
if self.editor.found_results:
self.set_painter(painter, self.editor.found_results_color)
for line_number in self.editor.found_results:
painter.drawRect(make_flag(line_number))
# Paint the slider range
if not self._unit_testing:
alt = QApplication.queryKeyboardModifiers() & Qt.AltModifier
else:
alt = self._alt_key_is_down
cursor_pos = self.mapFromGlobal(QCursor().pos())
is_over_self = self.rect().contains(cursor_pos)
is_over_editor = self.editor.rect().contains(
self.editor.mapFromGlobal(QCursor().pos()))
# We use QRect.contains instead of QWidget.underMouse method to
# determined if the cursor is over the editor or the flag scrollbar
# because the later gives a wrong result when a mouse button
# is pressed.
if ((is_over_self or (alt and is_over_editor)) and self.slider):
pen_color = QColor(Qt.gray)
pen_color.setAlphaF(.85)
painter.setPen(pen_color)
brush_color = QColor(Qt.gray)
brush_color.setAlphaF(.5)
painter.setBrush(QBrush(brush_color))
painter.drawRect(self.make_slider_range(cursor_pos))
self._range_indicator_is_visible = True
else:
self._range_indicator_is_visible = False
def paintEvent(self, event):
"""Paint the colorbox. If no color, display a checkerboard pattern.
Parameters
----------
event : qtpy.QtCore.QEvent
Event from the Qt context.
"""
painter = QPainter(self)
if self.layer._selected_color is None:
for i in range(self._height // 4):
for j in range(self._height // 4):
if (i % 2 == 0 and j % 2 == 0) or (i % 2 == 1
and j % 2 == 1):
painter.setPen(QColor(230, 230, 230))
painter.setBrush(QColor(230, 230, 230))
else:
painter.setPen(QColor(25, 25, 25))
painter.setBrush(QColor(25, 25, 25))
painter.drawRect(i * 4, j * 4, 5, 5)
else:
color = np.multiply(self.layer._selected_color, self.layer.opacity)
color = np.round(255 * color).astype(int)
painter.setPen(QColor(*list(color)))
painter.setBrush(QColor(*list(color)))
painter.drawRect(0, 0, self._height, self._height)
def paintEvent(self, event):
"""
Override Qt method.
Painting the scroll flag area
"""
make_flag = self.make_flag_qrect
make_slider = self.make_slider_range
# Filling the whole painting area
painter = QPainter(self)
painter.fillRect(event.rect(), self.editor.sideareas_color)
block = self.editor.document().firstBlock()
# Painting warnings and todos
for line_number in range(1, self.editor.document().blockCount()+1):
data = block.userData()
if data:
position = self.value_to_position(line_number)
if data.code_analysis:
# Warnings
color = self.editor.warning_color
for _message, error in data.code_analysis:
if error:
color = self.editor.error_color
break
self.set_painter(painter, color)
painter.drawRect(make_flag(position))
if data.todo:
# TODOs
self.set_painter(painter, self.editor.todo_color)
painter.drawRect(make_flag(position))
if data.breakpoint:
# Breakpoints
self.set_painter(painter, self.editor.breakpoint_color)
painter.drawRect(make_flag(position))
block = block.next()
# Occurrences
if self.editor.occurrences:
self.set_painter(painter, self.editor.occurrence_color)
for line_number in self.editor.occurrences:
position = self.value_to_position(line_number)
painter.drawRect(make_flag(position))
# Found results
if self.editor.found_results:
self.set_painter(painter, self.editor.found_results_color)
for line_number in self.editor.found_results:
position = self.value_to_position(line_number)
painter.drawRect(make_flag(position))
# Painting the slider range
pen_color = QColor(Qt.white)
pen_color.setAlphaF(.8)
painter.setPen(pen_color)
brush_color = QColor(Qt.white)
brush_color.setAlphaF(.5)
painter.setBrush(QBrush(brush_color))
painter.drawRect(make_slider(self.editor.firstVisibleBlock().blockNumber()))
class BarIndicatorBase(QWidget):
"""docstring for BarIndicator"""
def __init__(self, parent=None):
super(BarIndicatorBase, self).__init__(parent)
self._value = 100
self._minimum = 0.0
self._maximum = 100.0
self._value_at_100_percent = 100.0
self._format = '$value %'
self._text_color = QColor(0, 0, 0)
self._border_color = Qt.gray
self._border_radius = 2
self._border_width = 1
self._painter = QPainter()
self._orientation = Qt.Horizontal
self._bar_width = self.height()
self._bar_length = self.width()
self._painter_rotation = None
self._painter_translation_y = None
self._painter_translation_x = None
self._painter_scale_x = None
self._flip_translation_y = None
self._flip_scale_y = None
self._inverted_appearance = False
self._flip_scale = False
self._origin_at_zero = False
self._origin_position = 0
self.barGradient = [
'0.0, 0, 255, 0',
'0.8, 255, 255, 0',
'1.0, 255, 0, 0',
]
def adjustTransformation(self):
"""This method sets parameters for the widget transformations (needed
for orientation, flipping and appearance inversion).
"""
if self._orientation == Qt.Horizontal:
self._bar_width = self.height()
self._bar_length = self.width()
self._painter_translation_y = 0
self._painter_rotation = 0
elif self._orientation == Qt.Vertical:
# Invert dimensions for paintEvent()
self._bar_width = self.width()
self._bar_length = self.height()
self._painter_translation_y = self._bar_length
self._painter_rotation = -90
if self._inverted_appearance:
self._painter_translation_x = self._bar_width
self._painter_scale_x = -1
else:
self._painter_translation_x = 0
self._painter_scale_x = 1
if self._flip_scale:
self._flip_translation_y = self._bar_length
self._flip_scale_y = -1
else:
self._flip_translation_y = 0
self._flip_scale_y = 1
def paintEvent(self, event):
self.adjustTransformation()
self._painter.begin(self)
self._painter.translate(
0, self._painter_translation_y) # Draw vertically if needed
self._painter.rotate(self._painter_rotation)
self._painter.translate(self._painter_translation_x,
0) # Invert appearance if needed
self._painter.scale(self._painter_scale_x, 1)
self._painter.translate(
0, self._flip_translation_y) # Invert scale if needed
self._painter.scale(1, self._flip_scale_y)
self._painter.setRenderHint(QPainter.Antialiasing)
self.drawBackground()
if self._border_width > 0:
self.drawBorder()
if self._format != '':
self.drawText()
self._painter.end()
def drawBackground(self):
bw = float(self._border_width)
br = self._border_radius
w = self.sliderPositionFromValue(self.minimum, self.maximum,
self._value, self._bar_length)
h = self._bar_width
rect = QRectF(bw / 2, bw / 2, w - bw, h - bw)
p = self._painter
# draw the load meter value bar
p.setPen(Qt.transparent)
p.setBrush(self.gradient)
p.drawRoundedRect(rect, br, br)
def drawBorder(self):
p = self._painter
bw = float(self._border_width)
br = self._border_radius
p.setBrush(Qt.transparent)
border_pen = QPen()
border_pen.setWidth(int(bw))
border_pen.setColor(self._border_color)
p.setPen(border_pen)
# deal with orientation
if self._orientation == Qt.Horizontal:
rect = QRectF(bw / 2, bw / 2,
self.width() - bw,
self.height() - bw)
else:
# must be Qt.Vertical
rect = QRectF(bw / 2, bw / 2,
self.height() - bw,
self.width() - bw)
p.drawRoundedRect(rect, br, br)
def drawText(self):
p = self._painter
# draw the load percentage text
p.setPen(self._text_color)
if self.orientation == Qt.Vertical:
p.drawText(0, 0, self.height(), self.width(), Qt.AlignCenter,
self.text())
else:
p.drawText(0, 0, self.width(), self.height(), Qt.AlignCenter,
self.text())
def minimumSizeHint(self):
return QSize(30, 30)
def resizeEvent(self, event):
if self._orientation == Qt.Horizontal:
self.gradient.setStart(0, 0)
self.gradient.setFinalStop(self.width(), 0)
else:
self.gradient.setStart(0, 0)
self.gradient.setFinalStop(self.height(), 0)
def sliderPositionFromValue(self, min, max, val, span, upsideDown=False):
return span * (val / max - min)
@Slot(int)
@Slot(float)
@Slot(object)
def setValue(self, val):
self.value = val
@Slot(int)
@Slot(float)
def setMinimum(self, min):
self.minimum = min
@Slot(int)
@Slot(float)
def setMaximum(self, max):
self.maximum = max
@Property(float)
def value(self):
return self._value
@value.setter
def value(self, value):
if value >= self.minimum and value <= self.maximum:
self._value = value
self.update()
@Property(float)
def minimum(self):
return self._minimum
@minimum.setter
def minimum(self, min_val):
self._minimum = min_val
self.update()
@Property(float)
def maximum(self):
return self._maximum
@maximum.setter
def maximum(self, max_val):
self._maximum = max_val
self.update()
@Property(str)
def format(self):
return self._format
@format.setter
def format(self, fmt):
self._format = fmt
self.update()
@Property(Qt.Orientation)
def orientation(self):
return self._orientation
@orientation.setter
def orientation(self, orient):
if orient == self._orientation:
return
self._orientation = orient
self.adjustTransformation()
self.update()
@Property(float)
def valueAt100Percent(self):
return self._value_at_100_percent
@valueAt100Percent.setter
def valueAt100Percent(self, value_at):
self._value_at_100_percent = value_at
self.update()
def text(self):
values = {
'v': self._value,
'p': int((self._value * 100 / self._value_at_100_percent) + .5)
}
try:
return Template(self._format).substitute(value=values['p'])
except:
return self.format
# ToDo: Make this a QLinearGradient
@Property('QStringList')
def barGradient(self):
return self._gradient_def
@barGradient.setter
def barGradient(self, gradient):
grad = QLinearGradient(0, 0, 0, 0)
try:
for stop in gradient:
pos, r, g, b = stop.split(',')[:4]
color = QColor(int(r), int(g), int(b))
grad.setColorAt(float(pos), color)
except:
LOG.exception('Invalid gradient.')
return
self._gradient_def = gradient
self.gradient = grad
self.resizeEvent(None)
self.update()
# text color
@Property(QColor)
def textColor(self):
return self._text_color
@textColor.setter
def textColor(self, text_color):
self._text_color = text_color
self.update()
# border color
@Property(QColor)
def borderColor(self):
return self._border_color
@borderColor.setter
def borderColor(self, border_color):
self._border_color = border_color
self.update()
# border radius
@Property(int)
def borderRadius(self):
return self._border_radius
@borderRadius.setter
def borderRadius(self, border_radius):
self._border_radius = border_radius
self.update()
# border width
@Property(int)
def borderWidth(self):
return self._border_width
@borderWidth.setter
def borderWidth(self, border_width):
self._border_width = border_width
self.update()
def paintEvent(self, e):
qp = QPainter()
qp.begin(self)
self.drawWidget(qp)
qp.end()
def paint(self, painter: QtGui.QPainter, option: 'QStyleOptionViewItem',
index: QtCore.QModelIndex) -> None:
if not index.isValid():
return
if option.state & QStyle.State_Selected:
pass
if option.state & QStyle.State_MouseOver:
pass
item = index.model().data(index, Qt.UserRole)
if isinstance(item, QVariant):
return
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setRenderHints(QPainter.SmoothPixmapTransform)
value = item['value']
type = item['type']
x = option.rect.x()
y = option.rect.y()
w = option.rect.width()
h = option.rect.height()
if type == 'device_activity':
painter.save()
# 图标
icon = QImage(ResourceLoader().icon_path(value['icon']))
rect_icon = QRectF(x + 20, y + 13, 44, 44)
painter.drawImage(rect_icon, icon)
# 设备标签
painter.setFont(ResourceLoader().qt_font_text_xs)
rect = calculate_text_rect('设备',
painter=painter,
x=x + 70,
y=y + 15)
painter.drawText(rect, Qt.TextSingleLine, '设备')
# 设备编号
painter.setPen(ResourceLoader().qt_color_label_link)
painter.setFont(ResourceLoader().qt_font_text_xs)
rect = calculate_text_rect(value['device'],
painter=painter,
x=x + 110,
y=y + 15)
painter.drawText(rect, Qt.TextSingleLine, value['device'])
# 活动内容
painter.setPen(ResourceLoader().qt_color_sub_text)
painter.setFont(ResourceLoader().qt_font_text_xss)
content = value['content'] + '，' + toDateStr()
rect = calculate_text_rect(content,
painter=painter,
x=x + 70,
y=y + 40)
painter.drawText(rect, Qt.TextSingleLine, content)
# 绘制边框
path = QPainterPath()
path.addRoundedRect(QRectF(x + 4, y + 4, w - 8, h - 8), 4, 4)
painter.strokePath(path,
QPen(ResourceLoader().qt_color_background, 1))
painter.restore()
elif type == 'load_more':
# 绘制加载图标
# painter.save()
# painter.translate(x+16, y+16)
# self.loading_rotate += 5
# painter.rotate(self.loading_rotate%360)
# icon = qtawesome.icon('mdi.loading', color=ResourceLoader().qt_color_sub_text)
# icon_pixmap = icon.pixmap(QSize(32, 32))
# painter.drawPixmap(QRect(-16, -16, 32, 32), icon_pixmap)
# painter.restore()
# 绘制加载信息
painter.save()
painter.setFont(ResourceLoader().qt_font_text_xs)
painter.setPen(ResourceLoader().qt_color_sub_text)
_rect = calculate_text_rect('~~~ 正在努力加载 ~~~', painter=painter)
rect = calculate_middle_rect(option.rect,
width=_rect.width(),
height=_rect.height())
painter.drawText(rect, Qt.TextSingleLine, '~~~ 正在努力加载 ~~~')
painter.restore()
elif type == 'no_more':
painter.save()
painter.setFont(ResourceLoader().qt_font_text_xs)
painter.setPen(ResourceLoader().qt_color_sub_text)
_rect = calculate_text_rect('--- 我是有底线的 ---', painter=painter)
rect = calculate_middle_rect(option.rect,
width=_rect.width(),
height=_rect.height())
painter.drawText(rect, Qt.TextSingleLine, '--- 我是有底线的 ---')
painter.restore()
else:
self.initStyleOption(option, index)
QStyledItemDelegate.paint(self, painter, option, index)
def paintEvent(self, event):
"""Override Qt method."""
painter = QPainter(self)
painter.setOpacity(self.current_opacity)
max_width = (SASS_VARIABLES.WIDGET_CONTENT_TOTAL_WIDTH -
2 * SASS_VARIABLES.WIDGET_CONTENT_PADDING -
2 * SASS_VARIABLES.WIDGET_CONTENT_MARGIN)
# Hover top
br = self.label_icon.rect().bottomRight()
tl = self.label_icon.rect().topLeft() + QPoint(1, 1)
y = br.y() + self.label_text.height() - 2
# br_new = QPoint(br.x() + 2, y) - QPoint(1, 1)
br_new = QPoint(max_width - 1, y) - QPoint(1, 1)
rect_hover = QRect(tl, br_new) # 2 is the border
pen = QPen(Qt.NoPen)
brush = QBrush(Qt.SolidPattern)
brush.setColor(QColor('#fff'))
painter.setBrush(brush)
painter.setPen(pen)
painter.drawRect(rect_hover)
font = self.font()
font.setPointSize(10)
painter.setFont(font)
pen = QPen()
pen.setColor(QColor('black'))
painter.setPen(pen)
td = self.text_document
td.setPageSize(QSizeF(rect_hover.size()))
td.setHtml(self.summary)
td.drawContents(painter)
self.raise_()
def paintEvent(self, event):
bw = float(self._border_width)
br = self._border_radius
val = self.value()
if self.orientation() == Qt.Horizontal:
w = QStyle.sliderPositionFromValue(self.minimum(), self.maximum(),
val, self.width())
h = self.height()
rect = QRectF(bw / 2, bw / 2, w - bw, h - bw)
else:
w = self.width()
h = self.height() - QStyle.sliderPositionFromValue(
self.minimum(), self.maximum(), val, self.height())
rect = QRectF(bw / 2, h - bw / 2, w - bw, self.height() - bw)
p = QPainter(self)
p.setRenderHint(QPainter.Antialiasing)
# draw the load meter value bar
p.setPen(Qt.transparent)
p.setBrush(self.gradient)
p.drawRoundedRect(rect, br, br)
# draw the border
p.setBrush(Qt.transparent)
border_pen = QPen()
border_pen.setWidth(bw)
border_pen.setColor(self._border_color)
p.setPen(border_pen)
rect = QRectF(bw / 2, bw / 2, self.width() - bw, self.height() - bw)
p.drawRoundedRect(rect, br, br)
# draw the load percentage text
p.setPen(self._text_color)
if self.orientation() == Qt.Vertical:
p.rotate(-90)
p.drawText(-self.height(), 0, self.height(), self.width(),
Qt.AlignCenter, self.text())
else:
p.drawText(0, 0, self.width(), self.height(), Qt.AlignCenter,
self.text())
def paintEvent(self, event):
"""Override Qt method.
Painting line number area
"""
painter = QPainter(self)
painter.fillRect(event.rect(), self.editor.sideareas_color)
# This is needed to make that the font size of line numbers
# be the same as the text one when zooming
# See Issue 2296 and 4811
font = self.editor.font()
font_height = self.editor.fontMetrics().height()
active_block = self.editor.textCursor().block()
active_line_number = active_block.blockNumber() + 1
def draw_pixmap(ytop, pixmap):
if not QT55_VERSION:
pixmap_height = pixmap.height()
else:
# scale pixmap height to device independent pixels
pixmap_height = pixmap.height() / pixmap.devicePixelRatio()
painter.drawPixmap(0, ytop + (font_height-pixmap_height) / 2,
pixmap)
for top, line_number, block in self.editor.visible_blocks:
if self._margin:
if line_number == active_line_number:
font.setWeight(font.Bold)
painter.setFont(font)
painter.setPen(self.editor.normal_color)
else:
font.setWeight(font.Normal)
painter.setFont(font)
painter.setPen(self.linenumbers_color)
painter.drawText(0, top, self.width(),
font_height,
Qt.AlignRight | Qt.AlignBottom,
to_text_string(line_number))
data = block.userData()
if self._markers_margin and data:
if data.code_analysis:
for source, code, severity, message in data.code_analysis:
error = severity == DiagnosticSeverity.ERROR
if error:
break
if error:
draw_pixmap(top, self.error_pixmap)
else:
draw_pixmap(top, self.warning_pixmap)
if data.todo:
draw_pixmap(top, self.todo_pixmap)
def paintEvent(self, event: QPaintEvent):
name = self.choose.currentText()
if self.widgets_dict[name].has_elements() and event.rect().top() == 0 and event.rect().left() == 0:
painter = QPainter(self)
painter.drawRect(event.rect())
def square_pixmap(size):
"""Create a white/black hollow square pixmap. For use as labels cursor."""
size = max(int(size), 1)
pixmap = QPixmap(QSize(size, size))
pixmap.fill(Qt.transparent)
painter = QPainter(pixmap)
painter.setPen(Qt.white)
painter.drawRect(0, 0, size - 1, size - 1)
painter.setPen(Qt.black)
painter.drawRect(1, 1, size - 3, size - 3)
painter.end()
return pixmap
def pixmap(self, size, mode, state):
pm = QPixmap(size)
pm.fill(Qt.transparent)
self.paint(QPainter(pm), QRect(QPoint(0, 0), size), mode, state)
return pm
def paintEvent(self, event):
"""
Override Qt method.
Painting the scroll flag area
"""
make_flag = self.make_flag_qrect
# Fill the whole painting area
painter = QPainter(self)
painter.fillRect(event.rect(), self.editor.sideareas_color)
# Paint warnings and todos
block = self.editor.document().firstBlock()
for line_number in range(self.editor.document().blockCount()+1):
data = block.userData()
if data:
if data.code_analysis:
# Paint the warnings
color = self.editor.warning_color
for source, code, severity, message in data.code_analysis:
error = severity == DiagnosticSeverity.ERROR
if error:
color = self.editor.error_color
break
self.set_painter(painter, color)
painter.drawRect(make_flag(line_number))
if data.todo:
# Paint the todos
self.set_painter(painter, self.editor.todo_color)
painter.drawRect(make_flag(line_number))
if data.breakpoint:
# Paint the breakpoints
self.set_painter(painter, self.editor.breakpoint_color)
painter.drawRect(make_flag(line_number))
block = block.next()
# Paint the occurrences
if self.editor.occurrences:
self.set_painter(painter, self.editor.occurrence_color)
for line_number in self.editor.occurrences:
painter.drawRect(make_flag(line_number))
# Paint the found results
if self.editor.found_results:
self.set_painter(painter, self.editor.found_results_color)
for line_number in self.editor.found_results:
painter.drawRect(make_flag(line_number))
# Paint the slider range
if not self._unit_testing:
alt = QApplication.queryKeyboardModifiers() & Qt.AltModifier
else:
alt = self._alt_key_is_down
cursor_pos = self.mapFromGlobal(QCursor().pos())
is_over_self = self.rect().contains(cursor_pos)
is_over_editor = self.editor.rect().contains(
self.editor.mapFromGlobal(QCursor().pos()))
# We use QRect.contains instead of QWidget.underMouse method to
# determined if the cursor is over the editor or the flag scrollbar
# because the later gives a wrong result when a mouse button
# is pressed.
if ((is_over_self or (alt and is_over_editor)) and self.slider):
pen_color = QColor(Qt.gray)
pen_color.setAlphaF(.85)
painter.setPen(pen_color)
brush_color = QColor(Qt.gray)
brush_color.setAlphaF(.5)
painter.setBrush(QBrush(brush_color))
painter.drawRect(self.make_slider_range(cursor_pos))
self._range_indicator_is_visible = True
else:
self._range_indicator_is_visible = False
def paintEvent(self, event):
"""Paint the background, range bar and splitters.
Parameters
----------
event : qtpy.QEvent
Event from the Qt context.
"""
painter, w, h = QPainter(self), self.width(), self.height()
half_width = self.slider_width / 2
halfdiff = w / 2 - half_width
# Background
painter.setPen(self.background_color)
painter.setBrush(self.background_color)
painter.drawRect(halfdiff, 0, self.slider_width, h)
# Range Bar
painter.setPen(self.bar_color)
painter.setBrush(self.bar_color)
if self.collapsed:
painter.drawRect(
halfdiff,
h - self.display_max,
self.slider_width,
self.display_max,
)
else:
painter.drawRect(
halfdiff,
h - self.display_max,
self.slider_width,
self.display_max - self.display_min,
)
painter.setRenderHints(QPainter.Antialiasing)
# Splitters
painter.setPen(self.handle_border_color)
painter.setBrush(self.handle_color)
painter.drawEllipse(
w / 2 - self.handle_radius,
h - self.display_min - self.handle_radius,
self.handle_width,
self.handle_width,
) # upper
painter.drawEllipse(
w / 2 - self.handle_radius,
h - self.display_max - self.handle_radius,
self.handle_width,
self.handle_width,
) # lower
def paintEvent(self, event):
QFrame.paintEvent(self, event)
painter = QPainter(self)
painter.setClipRect(self.contentsRect())
self.drawContents(painter)
def paintEvent(self, evt):
# get the widget dimensions
orig_width = self.width()
orig_height = self.height()
# fill perc % of the widget
perc = 1
width = int(orig_width * perc)
height = int(orig_height * perc)
# get the starting origin
x_orig = int((orig_width - width) / 2)
# we want to start at the bottom and draw up.
y_orig = orig_height - int((orig_height - height) / 2)
# a running x-position
running_pos = x_orig
# calculate to number of bars
nbars = len(self.counts)
# calculate the bar widths, this compilcation is
# necessary because integer trunction severly cripples
# the layout.
remainder = width % nbars
bar_width = [int(width / nbars)] * nbars
for i in range(remainder):
bar_width[i] += 1
paint = QPainter()
paint.begin(self)
# determine the scaling factor
max_val = np.max(self.counts)
scale = 1. * height / max_val
# determine if we have a colormap and drop into the appopriate
# loop.
if hasattr(self.colormap[0], '__iter__'):
# assume we have a colormap
for i in range(len(self.counts)):
bar_height = self.counts[i]
r, g, b = self.colormap[i]
paint.setPen(QColor(r, g, b))
paint.setBrush(QColor(r, g, b))
paint.drawRect(running_pos, y_orig, bar_width[i],
-bar_height)
running_pos += bar_width[i]
else:
# we have a tuple
r, g, b = self.colormap
paint.setPen(QColor(r, g, b))
paint.setBrush(QColor(r, g, b))
for i in range(len(self.counts)):
bar_height = self.counts[i] * scale
paint.drawRect(running_pos, y_orig, bar_width[i],
-bar_height)
running_pos += bar_width[i]
paint.end()
def paintEvent(self, event):
painter = QPainter(self)
painter.setRenderHints(QPainter.Antialiasing)
if self.label_width <= 0:
return
painter.setPen(Qt.NoPen)
if self.hover:
painter.setBrush(
QColor(self.back_color.red() + 30,
self.back_color.green() + 30,
self.back_color.blue() + 30))
else:
painter.setBrush(self.back_color)
painter.drawRoundedRect(QRect(0, 0, self.width(), self.height()),
self.border_radius, self.border_radius)
x1 = QPointF(self.label_width + float(self.height() / 3),
float(self.height() * 0.45))
x2 = QPointF(
self.label_width + float(self.height() * (0.66 + self.rate) / 2),
float(self.height() * 0.55))
x3 = QPointF(self.width() - float(self.height() / 3),
float(self.height() * 0.45))
check_path = QPainterPath()
check_path.moveTo(x1)
check_path.lineTo(x2)
check_path.lineTo(x3)
pen = QPen(self.text_color, self.drop_thick, Qt.SolidLine)
painter.setPen(pen)
painter.drawPath(check_path)
def paintEvent(self, event):
"""
Override Qt method.
Painting the scroll flag area
There is two cases:
- The scroll bar is moving, in which case paint all flags.
- The scroll bar is not moving, only paint flags corresponding
to visible lines.
"""
# The area in which the slider handle of the scrollbar may move.
groove_rect = self.get_scrollbar_groove_rect()
# The scrollbar's scale factor ratio between pixel span height and
# value span height
scale_factor = groove_rect.height() / self.get_scrollbar_value_height()
# The vertical offset of the scroll flag area relative to the
# top of the text editor.
offset = groove_rect.y()
# Note that we calculate the pixel metrics required to draw the flags
# here instead of using the convenience methods of the ScrollFlagArea
# for performance reason.
rect_x = ceil(self.FLAGS_DX / 2)
rect_w = self.WIDTH - self.FLAGS_DX
rect_h = self.FLAGS_DY
# Fill the whole painting area
painter = QPainter(self)
painter.fillRect(event.rect(), self.editor.sideareas_color)
editor = self.editor
# Define compute_flag_ypos to position the flags:
# Paint flags for the entire document
last_line = editor.document().lastBlock().firstLineNumber()
# The 0.5 offset is used to align the flags with the center of
# their corresponding text edit block before scaling.
first_y_pos = self.value_to_position(0.5, scale_factor,
offset) - self.FLAGS_DY / 2
last_y_pos = self.value_to_position(last_line + 0.5, scale_factor,
offset) - self.FLAGS_DY / 2
def compute_flag_ypos(block):
line_number = block.firstLineNumber()
if editor.verticalScrollBar().maximum() == 0:
geometry = editor.blockBoundingGeometry(block)
pos = geometry.y() + geometry.height() / 2 + self.FLAGS_DY / 2
elif last_line != 0:
frac = line_number / last_line
pos = first_y_pos + frac * (last_y_pos - first_y_pos)
else:
pos = first_y_pos
return ceil(pos)
# All the lists of block numbers for flags
dict_flag_lists = {
"occurrence": editor.occurrences,
"found_results": editor.found_results
}
dict_flag_lists.update(self._dict_flag_list)
for flag_type in dict_flag_lists:
painter.setBrush(self._facecolors[flag_type])
painter.setPen(self._edgecolors[flag_type])
for block_number in dict_flag_lists[flag_type]:
# Find the block
block = editor.document().findBlockByNumber(block_number)
if not block.isValid():
continue
# paint if everything else is fine
rect_y = compute_flag_ypos(block)
painter.drawRect(rect_x, rect_y, rect_w, rect_h)
# Paint the slider range
if not self._unit_testing:
alt = QApplication.queryKeyboardModifiers() & Qt.AltModifier
else:
alt = self._alt_key_is_down
if self.slider:
cursor_pos = self.mapFromGlobal(QCursor().pos())
is_over_self = self.rect().contains(cursor_pos)
is_over_editor = editor.rect().contains(
editor.mapFromGlobal(QCursor().pos()))
# We use QRect.contains instead of QWidget.underMouse method to
# determined if the cursor is over the editor or the flag scrollbar
# because the later gives a wrong result when a mouse button
# is pressed.
if is_over_self or (alt and is_over_editor):
painter.setPen(self._slider_range_color)
painter.setBrush(self._slider_range_brush)
x, y, width, height = self.make_slider_range(
cursor_pos, scale_factor, offset, groove_rect)
painter.drawRect(x, y, width, height)
self._range_indicator_is_visible = True
else:
self._range_indicator_is_visible = False
def paintEvent(self, event: QPaintEvent):
rect = event.rect()
painter = QPainter(self)
if self.parent().image is not None:
parent: "ColorSelector" = self.parent()
painter.drawImage(rect, parent.image)
def createPic(self, xmin, xmax):
picture = QPicture()
p = QPainter(picture)
[pic.play(p) for pic in self.pictures[xmin:xmax]]
p.end()
return picture
def setCommands(self, commands):
self.reset()
painter = QPainter(self)
for cmd in commands:
qwtExecCommand(painter, cmd, 0, QTransform(), None)
painter.end()
def paintEvent(self, e):
if self.points is None:
return
painter = QPainter(self)
pen = QPen() # creates a default pen
pen.setWidth(2)
pen.setCapStyle(Qt.RoundCap)
pen.setJoinStyle(Qt.RoundJoin)
painter.setPen(pen)
painter.setRenderHint(QPainter.Antialiasing)
# to avoid zero division
m = max(max(self.points), 10)
for i, v in enumerate(self.points):
pen.setBrush(self.colors[min(v * len(self.colors) // m,
len(self.colors) - 1)])
painter.setPen(pen)
painter.drawLine(
40 + 5 * i,
self.height() // 2 - min(v, self.height()) // 2,
40 + 5 * i,
self.height() // 2 + min(v, self.height()) // 2,
)
painter.end()
def paintEvent(self, event):
"""Override Qt method.
Painting line number area
"""
painter = QPainter(self)
painter.fillRect(event.rect(), self.editor.sideareas_color)
# This is needed to make that the font size of line numbers
# be the same as the text one when zooming
# See Issue 2296 and 4811
font = self.editor.font()
font_height = self.editor.fontMetrics().height()
active_block = self.editor.textCursor().block()
active_line_number = active_block.blockNumber() + 1
def draw_pixmap(ytop, pixmap):
if not QT55_VERSION:
pixmap_height = pixmap.height()
else:
# scale pixmap height to device independent pixels
pixmap_height = pixmap.height() / pixmap.devicePixelRatio()
painter.drawPixmap(0, ytop + (font_height - pixmap_height) / 2,
pixmap)
for top, line_number, block in self.editor.visible_blocks:
if self._margin:
if line_number == active_line_number:
font.setWeight(font.Bold)
painter.setFont(font)
painter.setPen(self.editor.normal_color)
else:
font.setWeight(font.Normal)
painter.setFont(font)
painter.setPen(self.linenumbers_color)
painter.drawText(0, top, self.width(), font_height,
Qt.AlignRight | Qt.AlignBottom,
to_text_string(line_number))
data = block.userData()
if self._markers_margin and data:
if data.code_analysis:
for source, code, severity, message in data.code_analysis:
error = severity == DiagnosticSeverity.ERROR
if error:
break
if error:
draw_pixmap(top, self.error_pixmap)
else:
draw_pixmap(top, self.warning_pixmap)
if data.todo:
draw_pixmap(top, self.todo_pixmap)
def circle_pixmap(size: int):
"""Create a white/black hollow circle pixmap. For use as labels cursor."""
size = int(size)
pixmap = QPixmap(QSize(size, size))
pixmap.fill(Qt.transparent)
painter = QPainter(pixmap)
painter.setPen(Qt.white)
painter.drawEllipse(0, 0, size - 1, size - 1)
painter.setPen(Qt.black)
painter.drawEllipse(1, 1, size - 3, size - 3)
painter.end()
return pixmap
def paintEvent(self, event):
"""
Override Qt method.
Painting the scroll flag area
"""
# The area in which the slider handle of the scrollbar may move.
groove_rect = self.get_scrollbar_groove_rect()
# The scrollbar's scale factor ratio between pixel span height and
# value span height
scale_factor = groove_rect.height() / self.get_scrollbar_value_height()
# The vertical offset of the scroll flag area relative to the
# top of the text editor.
offset = groove_rect.y()
# Note that we calculate the pixel metrics required to draw the flags
# here instead of using the convenience methods of the ScrollFlagArea
# for performance reason.
rect_x = ceil(self.FLAGS_DX / 2)
rect_w = self.WIDTH - self.FLAGS_DX
rect_h = self.FLAGS_DY
# Fill the whole painting area
painter = QPainter(self)
painter.fillRect(event.rect(), self.editor.sideareas_color)
# Paint warnings and todos
block = self.editor.document().firstBlock()
for line_number in range(self.editor.document().blockCount() + 1):
data = block.userData()
if data:
if data.code_analysis:
# Paint the warnings
for source, code, severity, message in data.code_analysis:
error = severity == DiagnosticSeverity.ERROR
if error:
painter.setBrush(self._facecolors['error'])
painter.setPen(self._edgecolors['error'])
break
else:
painter.setBrush(self._facecolors['warning'])
painter.setPen(self._edgecolors['warning'])
rect_y = self.calcul_flag_ypos(line_number, scale_factor,
offset)
painter.drawRect(rect_x, rect_y, rect_w, rect_h)
if data.todo:
# Paint the todos
rect_y = self.calcul_flag_ypos(line_number, scale_factor,
offset)
painter.setBrush(self._facecolors['todo'])
painter.setPen(self._edgecolors['todo'])
painter.drawRect(rect_x, rect_y, rect_w, rect_h)
if data.breakpoint:
# Paint the breakpoints
rect_y = self.calcul_flag_ypos(line_number, scale_factor,
offset)
painter.setBrush(self._facecolors['breakpoint'])
painter.setPen(self._edgecolors['breakpoint'])
painter.drawRect(rect_x, rect_y, rect_w, rect_h)
block = block.next()
# Paint the occurrences
if self.editor.occurrences:
painter.setBrush(self._facecolors['occurrence'])
painter.setPen(self._edgecolors['occurrence'])
for line_number in self.editor.occurrences:
rect_y = self.calcul_flag_ypos(line_number, scale_factor,
offset)
painter.drawRect(rect_x, rect_y, rect_w, rect_h)
# Paint the found results
if self.editor.found_results:
painter.setBrush(self._facecolors['found_results'])
painter.setPen(self._edgecolors['found_results'])
for line_number in self.editor.found_results:
rect_y = self.calcul_flag_ypos(line_number, scale_factor,
offset)
painter.drawRect(rect_x, rect_y, rect_w, rect_h)
# Paint the slider range
if not self._unit_testing:
alt = QApplication.queryKeyboardModifiers() & Qt.AltModifier
else:
alt = self._alt_key_is_down
if self.slider:
cursor_pos = self.mapFromGlobal(QCursor().pos())
is_over_self = self.rect().contains(cursor_pos)
is_over_editor = self.editor.rect().contains(
self.editor.mapFromGlobal(QCursor().pos()))
# We use QRect.contains instead of QWidget.underMouse method to
# determined if the cursor is over the editor or the flag scrollbar
# because the later gives a wrong result when a mouse button
# is pressed.
if is_over_self or (alt and is_over_editor):
painter.setPen(self._slider_range_color)
painter.setBrush(self._slider_range_brush)
x, y, width, height = self.make_slider_range(
cursor_pos, scale_factor, offset, groove_rect)
painter.drawRect(x, y, width, height)
self._range_indicator_is_visible = True
else:
self._range_indicator_is_visible = False
class QScale(QFrame):
"""
A bar-shaped indicator for scalar value.
Configurable features include indicator type (bar/pointer), scale tick
marks and orientation (horizontal/vertical).
Parameters
----------
parent : QWidget
The parent widget for the Scale
"""
def __init__(self, parent=None):
super(QScale, self).__init__(parent)
self._value = 1
self._lower_limit = -5
self._upper_limit = 5
self.position = None # unit: pixel
self._bg_color = QColor('darkgray')
self._bg_size_rate = 0.8 # from 0 to 1
self._indicator_color = QColor('black')
self._pointer_width_rate = 0.05
self._barIndicator = False
self._num_divisions = 10
self._show_ticks = True
self._tick_pen = QPen()
self._tick_color = QColor('black')
self._tick_width = 0
self._tick_size_rate = 0.1 # from 0 to 1
self._painter = QPainter()
self._painter_rotation = None
self._painter_translation_y = None
self._painter_translation_x = None
self._painter_scale_x = None
self._flip_traslation_y = None
self._flip_scale_y = None
self._widget_width = self.width()
self._widget_height = self.height()
self._orientation = Qt.Horizontal
self._inverted_appearance = False
self._flip_scale = False
self._scale_height = 35
self._origin_at_zero = False
self._origin_position = 0
self.set_position()
def adjust_transformation(self):
"""
This method sets parameters for the widget transformations (needed to for
orientation, flipping and appearance inversion).
"""
self.setMaximumSize(QWIDGETSIZE_MAX, QWIDGETSIZE_MAX) # Unset fixed size
if self._orientation == Qt.Horizontal:
self._widget_width = self.width()
self._widget_height = self.height()
self._painter_translation_y = 0
self._painter_rotation = 0
self.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Fixed)
self.setFixedHeight(self._scale_height)
elif self._orientation == Qt.Vertical:
# Invert dimensions for paintEvent()
self._widget_width = self.height()
self._widget_height = self.width()
self._painter_translation_y = self._widget_width
self._painter_rotation = -90
self.setSizePolicy(QSizePolicy.Fixed, QSizePolicy.Expanding)
self.setFixedWidth(self._scale_height)
if self._inverted_appearance:
self._painter_translation_x = self._widget_width
self._painter_scale_x = -1
else:
self._painter_translation_x = 0
self._painter_scale_x = 1
if self._flip_scale:
self._flip_traslation_y = self._widget_height
self._flip_scale_y = -1
else:
self._flip_traslation_y = 0
self._flip_scale_y = 1
def set_tick_pen(self):
"""
Define pen style for drawing scale tick marks.
"""
self._tick_pen.setColor(self._tick_color)
self._tick_pen.setWidth(self._tick_width)
def draw_ticks(self):
"""
Draw tick marks on the scale.
"""
if not self._show_ticks:
return
self.set_tick_pen()
self._painter.setPen(self._tick_pen)
division_size = self._widget_width / self._num_divisions
tick_y0 = self._widget_height
tick_yf = (1 - self._tick_size_rate)*self._widget_height
for i in range(self._num_divisions+1):
x = i*division_size
self._painter.drawLine(x, tick_y0, x, tick_yf) # x1, y1, x2, y2
def draw_bar(self):
"""
Draw a bar as indicator of current value.
"""
self.set_origin()
self.set_position()
if self.position < 0 or self.position > self._widget_width:
return
self._painter.setPen(Qt.transparent)
self._painter.setBrush(self._indicator_color)
bar_width = self.position - self._origin_position
bar_height = self._bg_size_rate * self._widget_height
self._painter.drawRect(self._origin_position, 0, bar_width, bar_height)
def draw_pointer(self):
"""
Draw a pointer as indicator of current value.
"""
self.set_position()
if self.position < 0 or self.position > self._widget_width:
return
self._painter.setPen(Qt.transparent)
self._painter.setBrush(self._indicator_color)
pointer_width = self._pointer_width_rate * self._widget_width
pointer_height = self._bg_size_rate * self._widget_height
points = [
QPoint(self.position, 0),
QPoint(self.position + 0.5*pointer_width, 0.5*pointer_height),
QPoint(self.position, pointer_height),
QPoint(self.position - 0.5*pointer_width, 0.5*pointer_height)
]
self._painter.drawPolygon(QPolygon(points))
def draw_indicator(self):
"""
Draw the selected indicator for current value.
"""
if self._barIndicator:
self.draw_bar()
else:
self.draw_pointer()
def draw_background(self):
"""
Draw the background of the scale.
"""
self._painter.setPen(Qt.transparent)
self._painter.setBrush(self._bg_color)
bg_width = self._widget_width
bg_height = self._bg_size_rate * self._widget_height
self._painter.drawRect(0, 0, bg_width, bg_height)
def paintEvent(self, event):
"""
Paint events are sent to widgets that need to update themselves,
for instance when part of a widget is exposed because a covering
widget was moved.
Parameters
----------
event : QPaintEvent
"""
self.adjust_transformation()
self._painter.begin(self)
self._painter.translate(0, self._painter_translation_y) # Draw vertically if needed
self._painter.rotate(self._painter_rotation)
self._painter.translate(self._painter_translation_x, 0) # Invert appearance if needed
self._painter.scale(self._painter_scale_x, 1)
self._painter.translate(0, self._flip_traslation_y) # Invert scale if needed
self._painter.scale(1, self._flip_scale_y)
self._painter.setRenderHint(QPainter.Antialiasing)
self.draw_background()
self.draw_ticks()
self.draw_indicator()
self._painter.end()
def calculate_position_for_value(self, value):
"""
Calculate the position (pixel) in which the pointer should be drawn for a given value.
"""
if value < self._lower_limit or value > self._upper_limit or \
self._upper_limit - self._lower_limit == 0:
proportion = -1 # Invalid
else:
proportion = (value - self._lower_limit) / (self._upper_limit - self._lower_limit)
position = int(proportion * self._widget_width)
return position
def set_origin(self):
"""
Set the position (pixel) in which the origin should be drawn.
"""
if self._origin_at_zero:
self._origin_position = self.calculate_position_for_value(0)
else:
self._origin_position = 0
def set_position(self):
"""
Set the position (pixel) in which the pointer should be drawn.
"""
self.position = self.calculate_position_for_value(self._value)
def update_indicator(self):
"""
Update the position and the drawing of indicator.
"""
self.set_position()
self.repaint()
def set_value(self, value):
"""
Set a new current value for the indicator.
"""
self._value = value
self.update_indicator()
def set_upper_limit(self, new_limit):
"""
Set the scale upper limit.
Parameters
----------
new_limit : float
The upper limit of the scale.
"""
self._upper_limit = new_limit
def set_lower_limit(self, new_limit):
"""
Set the scale lower limit.
Parameters
----------
new_limit : float
The lower limit of the scale.
"""
self._lower_limit = new_limit
def get_show_ticks(self):
return self._show_ticks
def set_show_ticks(self, checked):
if self._show_ticks != bool(checked):
self._show_ticks = checked
self.repaint()
def get_orientation(self):
return self._orientation
def set_orientation(self, orientation):
self._orientation = orientation
self.adjust_transformation()
self.repaint()
def get_flip_scale(self):
return self._flip_scale
def set_flip_scale(self, checked):
self._flip_scale = bool(checked)
self.adjust_transformation()
self.repaint()
def get_inverted_appearance(self):
return self._inverted_appearance
def set_inverted_appearance(self, inverted):
self._inverted_appearance = inverted
self.adjust_transformation()
self.repaint()
def get_bar_indicator(self):
return self._barIndicator
def set_bar_indicator(self, checked):
if self._barIndicator != bool(checked):
self._barIndicator = checked
self.repaint()
def get_background_color(self):
return self._bg_color
def set_background_color(self, color):
self._bg_color = color
self.repaint()
def get_indicator_color(self):
return self._indicator_color
def set_indicator_color(self, color):
self._indicator_color = color
self.repaint()
def get_tick_color(self):
return self._tick_color
def set_tick_color(self, color):
self._tick_color = color
self.repaint()
def get_background_size_rate(self):
return self._bg_size_rate
def set_background_size_rate(self, rate):
if rate >= 0 and rate <=1 and self._bg_size_rate != rate:
self._bg_size_rate = rate
self.repaint()
def get_tick_size_rate(self):
return self._tick_size_rate
def set_tick_size_rate(self, rate):
if rate >= 0 and rate <=1 and self._tick_size_rate != rate:
self._tick_size_rate = rate
self.repaint()
def get_num_divisions(self):
return self._num_divisions
def set_num_divisions(self, divisions):
if isinstance(divisions, int) and divisions > 0 and self._num_divisions != divisions:
self._num_divisions = divisions
self.repaint()
def get_scale_height(self):
return self._scale_height
def set_scale_height(self, value):
self._scale_height = int(value)
self.adjust_transformation()
self.repaint()
def get_origin_at_zero(self):
return self._origin_at_zero
def set_origin_at_zero(self, checked):
if self._origin_at_zero != bool(checked):
self._origin_at_zero = checked
self.repaint()
def paintEvent(self, event):
"""Override Qt method.
Painting line number area
"""
painter = QPainter(self)
painter.fillRect(event.rect(), self.editor.sideareas_color)
# This is needed to make that the font size of line numbers
# be the same as the text one when zooming
# See spyder-ide/spyder#2296 and spyder-ide/spyder#4811.
font = self.editor.font()
font_height = self.editor.fontMetrics().height()
active_block = self.editor.textCursor().block()
active_line_number = active_block.blockNumber() + 1
def draw_pixmap(xleft, ytop, pixmap):
if not QT55_VERSION:
pixmap_height = pixmap.height()
else:
# scale pixmap height to device independent pixels
pixmap_height = pixmap.height() / pixmap.devicePixelRatio()
painter.drawPixmap(xleft,
ceil(ytop + (font_height - pixmap_height) / 2),
pixmap)
for top, line_number, block in self.editor.visible_blocks:
if self._margin:
if line_number == active_line_number:
font.setWeight(font.Bold)
painter.setFont(font)
painter.setPen(self.editor.normal_color)
else:
font.setWeight(font.Normal)
painter.setFont(font)
painter.setPen(self.linenumbers_color)
painter.drawText(0, top, self.width(), font_height,
int(Qt.AlignRight | Qt.AlignBottom),
to_text_string(line_number))
size = self.get_markers_margin() - 2
icon_size = QSize(size, size)
data = block.userData()
if self._markers_margin and data:
if data.code_analysis:
errors = 0
warnings = 0
infos = 0
hints = 0
for _, _, sev, _ in data.code_analysis:
errors += sev == DiagnosticSeverity.ERROR
warnings += sev == DiagnosticSeverity.WARNING
infos += sev == DiagnosticSeverity.INFORMATION
hints += sev == DiagnosticSeverity.HINT
if errors:
draw_pixmap(1, top, self.error_icon.pixmap(icon_size))
elif warnings:
draw_pixmap(1, top,
self.warning_icon.pixmap(icon_size))
elif infos:
draw_pixmap(1, top, self.info_icon.pixmap(icon_size))
elif hints:
draw_pixmap(1, top, self.hint_icon.pixmap(icon_size))
if data.todo:
draw_pixmap(1, top, self.todo_icon.pixmap(icon_size))
def paintEvent(self, event):
QPushButton.paintEvent(self, event)
color = self.color()
padding = self.padding()
rect = event.rect()
painter = QPainter()
painter.begin(self)
painter.setBrush(QBrush(color))
painter.setPen(Qt.NoPen)
rect.adjust(padding, padding, -1 - padding, -1 - padding)
painter.drawRect(rect)
painter.end()
def paintEvent(self, evt):
# get the widget dimensions
orig_width = self.width()
orig_height = self.height()
# fill perc % of the widget
perc = 1
width = int(orig_width * perc)
height = int(orig_height * perc)
# get the starting origin
x_orig = int((orig_width - width) / 2)
# we want to start at the bottom and draw up.
y_orig = orig_height - int((orig_height - height) / 2)
# a running x-position
running_pos = x_orig
# calculate to number of bars
nbars = len(self.counts)
# calculate the bar widths, this compilcation is
# necessary because integer trunction severely cripples
# the layout.
remainder = width % nbars
bar_width = [int(width / nbars)] * nbars
for i in range(remainder):
bar_width[i] += 1
paint = QPainter()
paint.begin(self)
# determine the scaling factor
max_val = np.max(self.counts)
scale = 1. * height / max_val
# determine if we have a colormap and drop into the appropriate
# loop.
if hasattr(self.colormap[0], '__iter__'):
# assume we have a colormap
for i in range(len(self.counts)):
bar_height = self.counts[i]
r, g, b = self.colormap[i]
paint.setPen(QColor(r, g, b))
paint.setBrush(QColor(r, g, b))
paint.drawRect(running_pos, y_orig, bar_width[i], -bar_height)
running_pos += bar_width[i]
else:
# we have a tuple
r, g, b = self.colormap
paint.setPen(QColor(r, g, b))
paint.setBrush(QColor(r, g, b))
for i in range(len(self.counts)):
bar_height = self.counts[i] * scale
paint.drawRect(running_pos, y_orig, bar_width[i], -bar_height)
running_pos += bar_width[i]
paint.end()
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)
painter.drawRoundedRect(
QRect(0, -self._lineWidth / 2, self._lineLength,
self._lineWidth), self._roundness, self._roundness,
Qt.RelativeSize)
painter.restore()
def paint(self, p=QPainter(), o=QStyleOptionGraphicsItem(), widget=None):
super(RotateHandle, self).paint(p, o, widget)
p.drawEllipse(self.__r)
