def paintEvent(self, e): #define the painter painter = QPainter(self) #define a brush for the background of the axis area brush = QtGui.QBrush() brush.setColor(QtGui.QColor('black')) brush.setStyle(Qt.SolidPattern) #define a rectangle to fill the axis area background rect = QtCore.QRect(0, 0, painter.device().width(), painter.device().height()) painter.fillRect(rect, brush) #define width and height for centering w = self.width() h = self.height() title = QtGui.QPen() title.setColor(QtGui.QColor('white')) painter.setPen(title) painter.setOpacity(1) font = QtGui.QFont() #set up the text labels font.setBold(True) font.setPointSize(18) painter.setFont(font) painter.drawText(QRect(0, 0, w, h), Qt.AlignCenter | Qt.AlignCenter, self.plotTitle)
def paint_over_unavailable_regions(self, filter_name): painter = QPainter() painter.begin(self) pen = QPen(Qt.transparent) painter.setPen(pen) brush = QBrush(self.colors[filter_name], Qt.SolidPattern) painter.setBrush(brush) if len(self.images.get(filter_name, [])) == 0: return width = painter.device().width() - 2 * self.handle_width height = painter.device().height() step = width / len(self.images[filter_name]) position = self.handle_width index = 0 while index < len(self.images[filter_name]): start = position while index < len(self.images[filter_name]) and not self.images[filter_name][index]: position += step index += 1 if start != position: painter.drawRect(start, 0, position - start, height) position += step index += 1 painter.end()
def paintEvent(self, event): # pylint: disable = unused-argument painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing) width = painter.device().width() height = painter.device().height() # Gradient draw pass gradient = QLinearGradient(0, 0, width, 0) for stop, color in self.gradient.items(): gradient.setColorAt(stop, QColor(*color)) painter.fillRect(0, 0, width, height, gradient) # Handles draw pass pen = QPen() pen.setWidth(3) pen.setColor(QColor(255, 255, 255, 191)) painter.setPen(pen) y = height / 2 for pos in self.gradient.keys(): x = pos * width painter.drawLine( QPoint(x, y - 12), QPoint(x, y + 12) ) painter.drawEllipse(QPoint(x, y), 6, 6) painter.end()
def paintEvent(self, event): """Draws the current state of the game in the window. """ painter = QPainter(self) brush = QBrush() window_width = painter.device().width() window_height = painter.device().height() # Paint background brush.setColor(QColor(BACKGROUND_COLOR)) brush.setStyle(Qt.SolidPattern) background = QRect(0, 0, window_width, window_height) painter.fillRect(background, brush) # Keep game centered in window start_x = (window_width - GAME_WIDTH) / 2 start_y = (window_height - GAME_HEIGHT) / 2 cell_width = GAME_WIDTH / N_COLS cell_height = GAME_HEIGHT / N_ROWS # Paint living cells for i in range(N_ROWS): for j in range(N_COLS): if self._cells[i][j].alive: # Get cell color based on age brush.setColor(QColor(self._cells[i][j].get_color())) # Calculate cell coordinates cell_x = start_x + cell_width * j cell_y = start_y + cell_height * i # Draw cell in window cell = QRect(cell_x, cell_y, cell_width, cell_height) painter.fillRect(cell, brush)
def paintEvent(self, e): painter = QPainter(self) brush = QtGui.QBrush() brush.setColor(QColor('black')) brush.setStyle(Qt.SolidPattern) painter.setBrush(brush) rect = QtCore.QRect(0, 0, painter.device().width(), painter.device().height()) painter.fillRect(rect, brush) keyframes_indices = self.parent.selected_text_template.keyframes.keyframes_frames_indices slider = self.parent.frames_slider pen = QPen() pen.setWidth(5) pen.setColor(QColor('red')) painter.setPen(pen) brush = QtGui.QBrush() brush.setColor(QColor('red')) brush.setStyle(Qt.SolidPattern) painter.setBrush(brush) for frame_ind in keyframes_indices: position = QStyle.sliderPositionFromValue(slider.minimum(), slider.maximum(), frame_ind, slider.width()) painter.drawEllipse(position, 10, 2, 2) painter.end()
def paintEvent(self, e): #define the painter painter = QPainter(self) #define a brush for the background of the axis area brush = QtGui.QBrush() brush.setColor(QtGui.QColor('black')) brush.setStyle(Qt.SolidPattern) #define a rectangle to fill the axis area background rect = QtCore.QRect(0, 0, painter.device().width(), painter.device().height()) painter.fillRect(rect, brush) #define the height and width of the area to be able to divide the ticks properly w = rect.width() h = rect.height() # draw opacity tick marker for x axis tick = QtGui.QPen() tick.setColor(QtGui.QColor('white')) painter.setPen(tick) painter.setOpacity(1) painter.drawLine(6 * w / 6, 0, 6 * w / 6, 5) painter.drawLine(5 * w / 6, 0, 5 * w / 6, 5) painter.drawLine(4 * w / 6, 0, 4 * w / 6, 5) painter.drawLine(3 * w / 6, 0, 3 * w / 6, 5) painter.drawLine(2 * w / 6, 0, 2 * w / 6, 5) painter.drawLine(1 * w / 6, 0, 1 * w / 6, 5) painter.drawLine(0 * w / 6, 0, 0 * w / 6, 5) #draw horizontal axis marker line painter.drawLine(0, 0, w, 0) # draw text x_label = QtGui.QPen() x_label.setColor(QtGui.QColor('white')) painter.setPen(x_label) painter.setOpacity(1) font = QtGui.QFont() #set up the text labels font.setBold(True) font.setPointSize(10) painter.setFont(font) painter.drawText(6 * w / 6 - 9, 20, '0') painter.drawText(5 * w / 6 - 7, 20, '10') painter.drawText(4 * w / 6 - 7, 20, '20') painter.drawText(3 * w / 6 - 7, 20, '30') painter.drawText(2 * w / 6 - 7, 20, '40') painter.drawText(1 * w / 6 - 7, 20, '50') painter.drawText(0 * w / 6 - 0, 20, '60') painter.drawText(QRect(0, 0, w, h), Qt.AlignCenter | Qt.AlignBottom, 'Time [seconds past]')
def paintEvent(self, event): painter = QPainter(self) painter.setBrush(Qt.darkGreen) painter.drawRect(self.rect()) img_rect = self.img.rect() dev_rect = QRect(0, 0, painter.device().width(), painter.device().height()) img_rect.moveCenter(dev_rect.center()) painter.drawPixmap(img_rect.topLeft(), self.img)
def paintEvent(self, e): #define the painter painter = QPainter(self) #define a brush for the background of the axis area brush = QtGui.QBrush() brush.setColor(QtGui.QColor('black')) brush.setStyle(Qt.SolidPattern) #define a rectangle to fill the axis area background rect = QtCore.QRect(0, 0, painter.device().width(), painter.device().height()) painter.fillRect(rect, brush)
def paintEvent(self, e): if self.v == 100: return p = QPainter(self) brush = QBrush(QColor(self.c[0], self.c[1], self.c[1], 127)) p.setBrush(brush) pen = QPen() pen.setStyle(Qt.NoPen) p.setPen(pen) start = 16 * 90 - 16 * 360 * (self.v / 100) span = -16 * 360 * (1 - (self.v / 100)) # start = 90*16 - 120*16 # span = -(360-120)*16 size = p.device().width() rect = QRectF(0, 0, size, size) # print(str(self.v)+str(self.val[1])+str(span)) p.drawPie(rect, start, span)
def redraw(self, painter: QtGui.QPainter, event) -> None: # if the button is hidden then there is nothing to draw if self._state == ICWidgetState.Hidden: return ######################################## # draw the label area ######################################## temp_width = painter.device().width() temp_height = painter.device().height() # define the rectangle to draw the button rect = QtCore.QRectF(3, 3, temp_width - 6, temp_height - 6) # path to be drawn path = QtGui.QPainterPath() path.setFillRule(Qt.WindingFill) path.addRoundedRect(rect, 10, 10) # brush to fill the area brush = QtGui.QLinearGradient(rect.topLeft(), rect.bottomRight()) if self._state == ICWidgetState.Transparent: brush.setColorAt(0, self.background_color) brush.setColorAt(1, self.background_color) else: brush.setColorAt(0, self._container_color_dark) brush.setColorAt(1, self._container_color_light) painter.setBrush(brush) # define the border pen if self._state == ICWidgetState.Transparent: pen = QtGui.QPen(self.background_color) else: pen = QtGui.QPen(self._container_border_color) if self.in_focus: pen.setWidth(3) else: pen.setWidth(1) pen.setCapStyle(Qt.RoundCap) pen.setJoinStyle(Qt.RoundJoin) painter.setPen(pen) # draw the rectangle painter.drawPath(path) ######################################## # draw the text only if the button is visible ######################################## if self._state in (ICWidgetState.VisibleEnabled, ICWidgetState.VisibleDisabled): # adjust the coordinate system for the border painter.translate(3, 3) temp_height -= 6 temp_width -= 6 ######################################## # draw the name and unit ######################################## fnt = painter.font() fnt.setBold(True) fnt.setPixelSize(self._name_text_size) painter.setFont(fnt) pen.setColor(self._name_color) painter.setPen(pen) half_width = 0.5 * temp_width rect = QtCore.QRectF(0, temp_height - (self._name_text_size + 5), half_width, self._name_text_size + 5) painter.drawText(rect, Qt.AlignRight, str(self._name)) # draw the unit fnt.setPixelSize(self._unit_text_size) painter.setFont(fnt) rect = QtCore.QRectF(half_width, temp_height - (self._unit_text_size + 5), half_width, self._unit_text_size + 5) painter.drawText(rect, Qt.AlignLeft, " ({})".format(self._unit)) # adjust for remaining height temp_height -= max(self._name_text_size, self._unit_text_size) ######################################## # draw the value ######################################## fnt.setPixelSize(self._value_text_size) painter.setFont(fnt) pen.setColor(self._value_color) painter.setPen(pen) # calculate dimension for the text and rotary gauge font_matrices = QtGui.QFontMetrics(fnt) text_size = font_matrices.horizontalAdvance(str(self._value)) box_length = sqrt(2) * (max(text_size, self._value_text_size + 5) + 5) # draw the value rect = QtCore.QRectF(10, (temp_height - (self._value_text_size + 5)) / 2, temp_width - 20, self._value_text_size + 5) painter.drawText(rect, Qt.AlignCenter, self._text_format.format(self._value)) ######################################## # main gauge ######################################## # create the gradient half_height = 0.5 * temp_height gradient = QtGui.QConicalGradient(half_width, half_height, 90) if self.alarm_activated: gradient.setColorAt(0, self._gauge_color_alarm_light) gradient.setColorAt(1, self._gauge_color_alarm_dark) else: gradient.setColorAt(0, self._gauge_color_normal_light) gradient.setColorAt(1, self._gauge_color_normal_dark) painter.setBrush(gradient) pen.setBrush(gradient) painter.setPen(pen) # calculate the path path = QtGui.QPainterPath() path.setFillRule(Qt.OddEvenFill) theta = 360 * (self._value - self._gauge_range_min) / ( self._gauge_range_max - self._gauge_range_min) # smaller radius half_box_length = box_length / 2 rect = QtCore.QRectF(half_width - half_box_length, half_height - half_box_length, box_length, box_length) path.moveTo(half_width, half_height - half_box_length) path.arcTo(rect, 90, -theta) pos = path.currentPosition() # bigger radius bigger_box_half_length = min(half_width, half_height) - 10 rect_big = QtCore.QRectF(half_width - bigger_box_half_length, half_height - bigger_box_half_length, 2 * bigger_box_half_length, 2 * bigger_box_half_length) new_x = half_width + (pos.x() - half_width ) * bigger_box_half_length / half_box_length new_y = half_height + (pos.y() - half_height ) * bigger_box_half_length / half_box_length path.lineTo(new_x, new_y) path.arcTo(rect_big, 90 - theta, theta) path.closeSubpath() # paint the gauge painter.drawPath(path) # draw gauge border pen = QtGui.QPen(self._container_border_color) pen.setWidth(1) pen.setCapStyle(Qt.RoundCap) pen.setJoinStyle(Qt.RoundJoin) painter.setPen(pen) painter.setBrush(QtGui.QBrush()) painter.drawEllipse(rect) painter.drawEllipse(rect_big) ######################################## # target line ######################################## if self._target_tracking: theta = 360 * (self._target_value - self._gauge_range_min) / ( self._gauge_range_max - self._gauge_range_min) # calculate the path path = QtGui.QPainterPath() path.arcMoveTo(rect, 90 - theta) pos = path.currentPosition() new_x = half_width + (pos.x( ) - half_width) * bigger_box_half_length / half_box_length new_y = half_height + (pos.y( ) - half_height) * bigger_box_half_length / half_box_length path.lineTo(new_x, new_y) # set up the pen pen.setColor(self._target_color) pen.setWidth(2) painter.setPen(pen) painter.drawPath(path) ######################################## # min max lines ######################################## if self._cycle_min_tracking: theta = 360 * (self._cycle_min - self._gauge_range_min) / ( self._gauge_range_max - self._gauge_range_min) # calculate the path path = QtGui.QPainterPath() path.arcMoveTo(rect, 90 - theta) pos = path.currentPosition() new_x = half_width + (pos.x( ) - half_width) * bigger_box_half_length / half_box_length new_y = half_height + (pos.y( ) - half_height) * bigger_box_half_length / half_box_length path.lineTo(new_x, new_y) # set up the pen pen.setColor(self._min_max_color) pen.setWidth(2) painter.setPen(pen) painter.drawPath(path) if self._cycle_max_tracking: theta = 360 * (self._cycle_max - self._gauge_range_min) / ( self._gauge_range_max - self._gauge_range_min) # calculate the path path = QtGui.QPainterPath() path.arcMoveTo(rect, 90 - theta) pos = path.currentPosition() new_x = half_width + (pos.x( ) - half_width) * bigger_box_half_length / half_box_length new_y = half_height + (pos.y( ) - half_height) * bigger_box_half_length / half_box_length path.lineTo(new_x, new_y) # set up the pen pen.setColor(self._min_max_color) pen.setWidth(2) painter.setPen(pen) painter.drawPath(path) ######################################## # upper and lower alarm lines ######################################## if self._alarm_lower_level_set: theta = 360 * (self._alarm_lower_level - self._gauge_range_min ) / (self._gauge_range_max - self._gauge_range_min) # calculate the path path = QtGui.QPainterPath() path.arcMoveTo(rect, 90 - theta) pos = path.currentPosition() new_x = half_width + (pos.x( ) - half_width) * bigger_box_half_length / half_box_length new_y = half_height + (pos.y( ) - half_height) * bigger_box_half_length / half_box_length path.lineTo(new_x, new_y) # set up the pen pen.setColor(self._alarm_color) pen.setWidth(2) painter.setPen(pen) painter.drawPath(path) if self._alarm_upper_level_set: theta = 360 * (self._alarm_upper_level - self._gauge_range_min ) / (self._gauge_range_max - self._gauge_range_min) # calculate the path path = QtGui.QPainterPath() path.arcMoveTo(rect, 90 - theta) pos = path.currentPosition() new_x = half_width + (pos.x( ) - half_width) * bigger_box_half_length / half_box_length new_y = half_height + (pos.y( ) - half_height) * bigger_box_half_length / half_box_length path.lineTo(new_x, new_y) # set up the pen pen.setColor(self._alarm_color) pen.setWidth(2) painter.setPen(pen) painter.drawPath(path)
def redraw(self, painter: QtGui.QPainter, vertical_offset: float = 0) -> None: # if the button is hidden then there is nothing to draw if self._state == ICWidgetState.Hidden: return # the size of the button is determined by the size of the widget tmp_width = painter.device().width() tmp_height = painter.device().height() # define the rectangle to draw the button rect = QtCore.QRectF(5, 5, tmp_width - 10, tmp_height - 10) # a linear gradient brush is used to fill the button brush = QtGui.QLinearGradient(rect.topRight(), rect.bottomRight()) # if the widget is transparent then the rect is drawn using background color if self._state == ICWidgetState.Transparent: brush.setColorAt(0, self.background_color) brush.setColorAt(1, self.background_color) else: brush.setColorAt(0, self._button_color_light) brush.setColorAt(1, self._button_color_dark) # set the brush painter.setBrush(brush) # define the pen that with rounded cap and join style if not self.in_focus: pen = QtGui.QPen() pen.setWidth(1) else: pen = QtGui.QPen(self.focus_color) pen.setWidth(3) pen.setCapStyle(Qt.RoundCap) pen.setJoinStyle(Qt.RoundJoin) # set the pen to use the brush and set the painter pen if not self.in_focus: pen.setBrush(brush) painter.setPen(pen) # define the path that needs to be drawn path = QtGui.QPainterPath() path.setFillRule(Qt.WindingFill) path.addRoundedRect(rect, 10, 10) painter.drawPath(path) # draw the text only if the button is visible if self._state in (ICWidgetState.VisibleEnabled, ICWidgetState.VisibleDisabled): # define the font for drawing fnt = painter.font() fnt.setBold(True) fnt.setPixelSize(self._text_size) painter.setFont(fnt) # select the font color based on if the button is enabled or not if self._state == ICWidgetState.VisibleEnabled: pen.setColor(self._text_color_enabled) else: pen.setColor(self._text_color_disabled) painter.setPen(pen) # draw the text rect = QtCore.QRectF(10, tmp_height / 2 - 0.5 * (self._text_size + 5) + vertical_offset, tmp_width - 20, self._text_size + 5) painter.drawText(rect, Qt.AlignCenter, str(self._name))
def drawIconWithShadow(icon: QIcon, rect: QRect, p: QPainter, iconMode: QIcon.Mode = None, dipRadius: int = None, color: QColor = None, dipOffset: QPoint = None): if iconMode is None: iconMode = QIcon.Normal if color is None: color = QColor(0, 0, 0, 130) if dipRadius is None: dipRadius = 3 if dipOffset is None: dipOffset = QPoint(1, -2) devicePixelRatio: int = p.device().devicePixelRatio() pixmapName = "icon %s %s %s %s" % (icon.cacheKey(), iconMode, rect.height(), devicePixelRatio) cache = QPixmapCache.find(pixmapName) if cache is None: # High-dpi support: The in parameters (rect, radius, offset) are in # device-independent pixels. The call to QIcon::pixmap() below might # return a high-dpi pixmap, which will in that case have a devicePixelRatio # different than 1. The shadow drawing caluculations are done in device # pixels. window = p.device().window().windowHandle() px = icon.pixmap(window, rect.size(), iconMode) radius = dipRadius * devicePixelRatio offset = dipOffset * devicePixelRatio cache = QPixmap(px.size() + QSize(radius * 2, radius * 2)) cache.fill(Qt.transparent) cachePainter = QPainter(cache) if iconMode == QIcon.Disabled: hasDisabledState = len(icon.availableSizes()) == len( icon.availableSizes(QIcon.Disabled)) if not hasDisabledState: px = disabledSideBarIcon(icon.pixmap(window, rect.size())) elif TOOLBAR_ICON_SHADOW: # Draw shadow tmp = QImage(px.size() + QSize(radius * 2, radius * 2 + 1), QImage.Format_ARGB32_Premultiplied) tmp.fill(Qt.transparent) tmpPainter = QPainter(tmp) tmpPainter.setCompositionMode(QPainter.CompositionMode_Source) tmpPainter.drawPixmap( QRect(radius, radius, px.width(), px.height()), px) tmpPainter.end() # blur the alpha channel blurred = QImage(tmp.size(), QImage.Format_ARGB32_Premultiplied) blurred.fill(Qt.transparent) blurPainter = QPainter(blurred) #qt_blurImage(blurPainter, tmp, radius, False, True) # implement qt_blurImage via QLabel with QGraphicsBlurEffect # FIXME: alignment is broken scene = QGraphicsScene() item = QGraphicsPixmapItem(QPixmap.fromImage(tmp)) effect = QGraphicsBlurEffect() effect.setBlurRadius(radius) item.setGraphicsEffect(effect) scene.addItem(item) scene.render(blurPainter) blurPainter.end() tmp = blurred # blacken the image... tmpPainter.begin(tmp) tmpPainter.setCompositionMode(QPainter.CompositionMode_SourceIn) tmpPainter.fillRect(tmp.rect(), color) tmpPainter.end() tmpPainter.begin(tmp) tmpPainter.setCompositionMode(QPainter.CompositionMode_SourceIn) tmpPainter.fillRect(tmp.rect(), color) tmpPainter.end() # draw the blurred drop shadow... cachePainter.drawImage( QRect(0, 0, cache.rect().width(), cache.rect().height()), tmp) # Draw the actual pixmap... cachePainter.drawPixmap( QRect( QPoint(radius, radius) + offset, QSize(px.width(), px.height())), px) cachePainter.end() cache.setDevicePixelRatio(devicePixelRatio) QPixmapCache.insert(pixmapName, cache) targetRect = cache.rect() targetRect.setSize(targetRect.size() / cache.devicePixelRatio()) targetRect.moveCenter(rect.center() - dipOffset) p.drawPixmap(targetRect, cache)
def redraw(self, painter: QtGui.QPainter, event) -> None: # if the button is hidden then there is nothing to draw if self._state == ICWidgetState.Hidden: return # draw the label area tmp_width = painter.device().width() tmp_height = painter.device().height() # define the rectangle to draw the button rect = QtCore.QRectF(3, 3, tmp_width-6, tmp_height-6) # path to be drawn path = QtGui.QPainterPath() path.setFillRule(Qt.WindingFill) path.addRoundedRect(rect, 10, 10) # brush to fill the area brush = QtGui.QLinearGradient(rect.topRight(), rect.bottomRight()) if self._state == ICWidgetState.Transparent: brush.setColorAt(0, self.background_color) brush.setColorAt(1, self.background_color) else: brush.setColorAt(0, self._label_color_dark) brush.setColorAt(0.5, self._label_color_light) brush.setColorAt(1, self._label_color_dark) painter.setBrush(brush) # define the border pen if self._state == ICWidgetState.Transparent: pen = QtGui.QPen(self.background_color) else: pen = QtGui.QPen(self._border_color) if self.in_focus: pen.setWidth(3) else: pen.setWidth(1) pen.setCapStyle(Qt.RoundCap) pen.setJoinStyle(Qt.RoundJoin) painter.setPen(pen) # draw the rectangle painter.drawPath(path) # draw the text only if the button is visible if self._state in (ICWidgetState.VisibleEnabled, ICWidgetState.VisibleDisabled): # draw the name fnt = painter.font() fnt.setBold(True) fnt.setPixelSize(self._name_text_size) painter.setFont(fnt) pen.setColor(self._name_color) painter.setPen(pen) rect = QtCore.QRect(10, 10, tmp_width - 20, self._name_text_size + 5) painter.drawText(rect, Qt.AlignLeft, str(self._name)) # draw the value fnt.setPixelSize(self._value_text_size) painter.setFont(fnt) pen.setColor(self._value_color) painter.setPen(pen) rect = QtCore.QRect(10, tmp_height - (self._value_text_size + 15), tmp_width - 20, self._value_text_size + 5) if self.__type == ICTextLabelType.LabelText: painter.drawText(rect, Qt.AlignRight, self._value) elif self.__type == ICTextLabelType.LabelInteger: painter.drawText(rect, Qt.AlignRight, str(self._value)) else: painter.drawText(rect, Qt.AlignRight, self._text_format.format(self._value))
def paintEvent(self, e): #define the painter painter = QPainter(self) #define a brush for the rectangle to fill in the background brush = QtGui.QBrush() brush.setColor(QtGui.QColor('black')) brush.setStyle(Qt.SolidPattern) #fill in the background of the canvas area rect = QtCore.QRect(0, 0, painter.device().width(), painter.device().height()) painter.fillRect(rect, brush) #define the height and width of the area to be able to divide the ticks properly w = rect.width() h = rect.height() # draw opacity tick marker for x axis tick = QtGui.QPen() tick.setColor(QtGui.QColor('white')) painter.setPen(tick) painter.setOpacity(1) #draw the top and right lines painter.drawLine(w - 1, 0, w - 1, h) painter.drawLine(0, 0, w - 1, 0) #draw on-canvas lines, dashed, to help see values painter.setOpacity(0.2) tick.setStyle(Qt.DashLine) painter.setPen(tick) #horizontal lines painter.drawLine(0, 4 * h / 5, w, 4 * h / 5) painter.drawLine(0, 3 * h / 5, w, 3 * h / 5) painter.drawLine(0, 2 * h / 5, w, 2 * h / 5) painter.drawLine(0, 1 * h / 5, w, 1 * h / 5) #vertical lines painter.drawLine(5 * w / 6, 0, 5 * w / 6, h) painter.drawLine(4 * w / 6, 0, 4 * w / 6, h) painter.drawLine(3 * w / 6, 0, 3 * w / 6, h) painter.drawLine(2 * w / 6, 0, 2 * w / 6, h) painter.drawLine(1 * w / 6, 0, 1 * w / 6, h) #define scale values for plot mx = (0 - w) / (60 - 0) bx = w my = (0 - h) / (self.parent()._VAxes.vertAxisMax - self.parent()._VAxes.vertAxisMin) by = h - my * self.parent()._VAxes.vertAxisMin #define pens for plots painter.setOpacity(1) colorA = QtGui.QPen() colorA.setColor(QtGui.QColor('red')) colorB = QtGui.QPen() colorB.setColor(QtGui.QColor('blue')) colorC = QtGui.QPen() colorC.setColor(QtGui.QColor('green')) colorD = QtGui.QPen() colorD.setColor(QtGui.QColor('yellow')) showA = self.parent().enables[0] == True and self.parent( ).display[0] == True showB = self.parent().enables[1] == True and self.parent( ).display[1] == True showC = self.parent().enables[2] == True and self.parent( ).display[2] == True showD = self.parent().enables[3] == True and self.parent( ).display[3] == True for i in range(len(self.valuesA) - 1): xPt1 = self.times[i] xPt2 = self.times[i + 1] if showA: yPt1 = self.valuesA[i] yPt2 = self.valuesA[i + 1] painter.setPen(colorA) painter.drawLine(mx * xPt1 + bx, my * yPt1 + by, mx * xPt2 + bx, my * yPt2 + by) if showB: yPt1 = self.valuesB[i] yPt2 = self.valuesB[i + 1] painter.setPen(colorB) painter.drawLine(mx * xPt1 + bx, my * yPt1 + by, mx * xPt2 + bx, my * yPt2 + by) if showC: yPt1 = self.valuesC[i] yPt2 = self.valuesC[i + 1] painter.setPen(colorC) painter.drawLine(mx * xPt1 + bx, my * yPt1 + by, mx * xPt2 + bx, my * yPt2 + by) if showD: yPt1 = self.valuesD[i] yPt2 = self.valuesD[i + 1] painter.setPen(colorD) painter.drawLine(mx * xPt1 + bx, my * yPt1 + by, mx * xPt2 + bx, my * yPt2 + by)
def paintEvent(self, e): #define the painter painter = QPainter(self) #define a brush for the background of the axis area brush = QtGui.QBrush() brush.setColor(QtGui.QColor('black')) brush.setStyle(Qt.SolidPattern) #define a rectangle to fill the axis area background rect = QtCore.QRect(0, 0, painter.device().width(), painter.device().height()) painter.fillRect(rect, brush) #define the height and width of the area to be able to divide the ticks properly w = rect.width() h = rect.height() # draw opacity tick marker for x axis tick = QtGui.QPen() tick.setColor(QtGui.QColor('white')) painter.setPen(tick) painter.setOpacity(1) painter.drawLine(w, 5 * h / 5 - 1, w - 5, 5 * h / 5 - 1) painter.drawLine(w, 4 * h / 5, w - 5, 4 * h / 5) painter.drawLine(w, 3 * h / 5, w - 5, 3 * h / 5) painter.drawLine(w, 2 * h / 5, w - 5, 2 * h / 5) painter.drawLine(w, 1 * h / 5, w - 5, 1 * h / 5) painter.drawLine(w, 0 * h / 5, w - 5, 0 * h / 5) #draw vertical axis marker line painter.drawLine(w - 1, 0, w - 1, h) # draw text x_label = QtGui.QPen() x_label.setColor(QtGui.QColor('white')) painter.setPen(x_label) painter.setOpacity(1) font = QtGui.QFont() #set up the text labels font.setBold(True) font.setPointSize(10) painter.setFont(font) #use the externally set maximum and minimum values t0 = str(self.vertAxisMin) t1 = str(self.vertAxisMin + (self.vertAxisMax - self.vertAxisMin) * 1 / 5) t2 = str(self.vertAxisMin + (self.vertAxisMax - self.vertAxisMin) * 2 / 5) t3 = str(self.vertAxisMin + (self.vertAxisMax - self.vertAxisMin) * 3 / 5) t4 = str(self.vertAxisMin + (self.vertAxisMax - self.vertAxisMin) * 4 / 5) t5 = str(self.vertAxisMin + (self.vertAxisMax - self.vertAxisMin) * 5 / 5) painter.drawText(QRect(w - 45, 5 * h / 5 - 16, 40, 20), Qt.AlignRight | Qt.AlignVCenter, t0) painter.drawText(QRect(w - 45, 4 * h / 5 - 10, 40, 20), Qt.AlignRight | Qt.AlignVCenter, t1) painter.drawText(QRect(w - 45, 3 * h / 5 - 10, 40, 20), Qt.AlignRight | Qt.AlignVCenter, t2) painter.drawText(QRect(w - 45, 2 * h / 5 - 10, 40, 20), Qt.AlignRight | Qt.AlignVCenter, t3) painter.drawText(QRect(w - 45, 1 * h / 5 - 10, 40, 20), Qt.AlignRight | Qt.AlignVCenter, t4) painter.drawText(QRect(w - 45, 0 * h / 5 - 4, 40, 20), Qt.AlignRight | Qt.AlignVCenter, t5) painter.translate(0, h) painter.rotate(-90.0) #pull in the axis label from outside the class painter.drawText(QRect(0, 0, h, w / 2), Qt.AlignCenter | Qt.AlignTop, self.axisLabel)