def draw_border(self): painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing) painter.translate(*self.center_p()) painter.setPen(QPen(Qt.green, 3)) x0, y0 = self.center_p() painter.drawRect(0 - x0, 0 - y0, self.width(), self.height())
def paintEvent(self, event): painter = QPainter(self) painter.setBrush(QBrush(Qt.white)) painter.setPen(Qt.NoPen) painter.drawRect(0, 0, self.width() - 1, self.height() - 1) painter.end() QSvgWidget.paintEvent(self, event)
def paintEvent(self, event=None): painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing, True) xOffset = self.width() / 3 yOffset = self.height() / 3 for x in range(3): for y in range(3): cell = self.grid[x][y] rect = (QRectF(x * xOffset, y * yOffset, xOffset, yOffset).adjusted(0.5, 0.5, -0.5, -0.5)) color = None if cell == RED: color = Qt.red elif cell == YELLOW: color = Qt.yellow if color is not None: painter.save() painter.setPen(Qt.black) painter.setBrush(color) painter.drawEllipse(rect.adjusted(2, 2, -2, -2)) painter.restore() if [x, y] == self.selected: painter.setPen(QPen(Qt.blue, 3)) else: painter.setPen(Qt.black) painter.drawRect(rect)
def paintEvent(self, e): if self.active: painter = QPainter(self) pen = painter.pen() pen.setWidth(self.margin) pen.setColor(QColor('red').dark(150)) painter.drawRect(0, 0, self.width(), self.height())
def __init__(self, parent, row, col): super(Board,self).__init__(parent) self.x = -1 self.y = -1 self.piece = None self.row = row self.col = col self.cellwidth = 50 self.linewidth = 1 self.width = self.cellwidth*col + self.linewidth*(col+1) self.height = self.cellwidth*row + self.linewidth*(row+1) self.setFixedSize(self.width, self.height) self.board = QImage(self.width, self.height, QImage.Format_ARGB32) self.pieces = QImage(self.width, self.height, QImage.Format_ARGB32) p = QPainter(self.board) p.setBrush(QColor(255, 255, 255, 255)) p.drawRect(QRect(0, 0, self.width-1, self.height-1)) linelist_x = [QLine(x, 0, x, self.height-1) for x in range(0, self.width, self.cellwidth+1)] linelist_y = [QLine(0, y, self.width-1, y) for y in range(0, self.height, self.cellwidth+1)] p.drawLines(linelist_x + linelist_y) self.pieces.fill(0x000000FF) self.setMouseTracking(True)
def paintEvent(self, event): QWidget.paintEvent(self, event) painter = QPainter(self) painter.setBrush(QBrush(QColor(Qt.black))) painter.setPen(QPen()) painter.setOpacity(self.value) painter.drawRect(self.rect())
def paintEvent(self, event=None): painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing, True) xOffset = self.width() / SIZE yOffset = self.height() / SIZE for x in range(SIZE): for y in range(SIZE): cell = self.grid[x][y] rect = (QRectF(x * xOffset, y * yOffset, xOffset, yOffset).adjusted(0.5, 0.5, -0.5, -0.5)) great_rect = QRectF(x * xOffset, y * yOffset, xOffset, yOffset) if cell != BLANK: painter.save() painter.setPen(Qt.black) font = QFont() font.setPointSize(20) painter.setFont(font) painter.drawText(rect, Qt.AlignCenter, cell) painter.restore() if [x, y] == self.selected: painter.setPen(QPen(Qt.blue, SIZE)) else: painter.setPen(Qt.black) painter.drawRect(rect)
def paintEvent(self, e): painter = QPainter(self) painter.setPen(self.color) painter.setBrush(Qt.NoBrush) rect = QRect(self.x,self.y,self.w,self.h) painter.drawRect(rect) QWidget.paintEvent(self, e)
def paintEvent(self, event): p = QPainter(self) p.fillRect(event.rect(), Qt.white) start = self.m_offset / self.m_height y = start * self.m_height - self.m_offset if self.m_offset <= 0: start = 0 y = -self.m_offset end = start + self.height() / self.m_height + 1 if end > len(self.m_colorNames) - 1: end = len(self.m_colorNames) - 1 for i in range(start, end): p.setBrush(Qt.NoBrush) p.setPen(Qt.black) if i == self.m_highlight: p.fillRect(0, y, self.width(), self.m_height, QColor(0, 64, 128)) p.setPen(Qt.white) if i == self.m_selected: p.fillRect(0, y, self.width(), self.m_height, QColor(0, 128, 240)) p.setPen(Qt.white) p.drawText(self.m_height + 2, y, self.width(), self.m_height, Qt.AlignVCenter, self.m_colorNames[i]) p.setPen(Qt.NoPen) p.setBrush(QBrush(self.m_firstColor[i])) p.drawRect(1, y + 1, self.m_height - 2, self.m_height - 2) p.setBrush(QBrush(self.m_secondColor[i])) p.drawRect(5, y + 5, self.m_height - 11, self.m_height - 11) y += self.m_height p.end()
def paintEvent( self, event ): """ Das automatisch ausgelöste paintEvent, das das Widget bei jeder Fensterveränderung neu zeichnet. """ if self.__maximum > 0: frameWidth = 1 separatorWidth = 1 # Damit der Rahmen nicht irgendwie abgeschnitten wird, muß das Quadrat entsprechend kleiner sein. squareSideLength = 10 framePen = QPen( frameWidth ) framePen.setColor( self.__colorFrame ) squareSideLengthPlus = squareSideLength + 2 * frameWidth painter = QPainter( self ) windowWidth = self.width() / min( self.__maximum, self.__columnMax ) windowHeight = self.__maximum / self.__columnMax windowHeight = math.ceil( windowHeight ) windowHeight = self.height() / windowHeight side = min( windowWidth, windowHeight ) painter.setRenderHint( QPainter.Antialiasing ) # Wenn das Widget disabled ist, muß ich den Alphakanal meiner Farben verändern. if ( not self.isEnabled() ): painter.setOpacity( .5 ) #painter.translate( float( windowWidth ), float( windowHeight ) ) painter.scale( side / squareSideLengthPlus, side / squareSideLengthPlus ) painter.setPen( framePen ) painter.setBrush( self.__colorEmpty ) painter.save() squareColumnIter = 0 squareLineIter = 0 squareCount = 0 for squareCount in range(self.__maximum): square = QRect( ( squareSideLength + separatorWidth ) * squareColumnIter + frameWidth * ( squareColumnIter + 1 ), ( squareSideLength + separatorWidth ) * squareLineIter + frameWidth * ( squareLineIter + 1 ), squareSideLength, squareSideLength ) painter.drawRect( square ) # Wir zeichnen die ausgekreuzten Quadrate if (self.__value > (self.__columnMax * squareLineIter + squareColumnIter)): painter.drawLine(square.bottomLeft(), square.topRight()) painter.drawLine(square.topLeft(), square.bottomRight()) squareColumnIter += 1 if ( squareColumnIter >= self.__columnMax ): squareColumnIter = 0 squareLineIter += 1 painter.restore()
def drawIcon(self, colorRamp): # input color ramp object: QgsVectorColorRampV2 object. # QgsVectorColorRampV2 is a virtual object, the real object name in # this case is QgsVectorGradientColorRampV2 object. mStops = colorRamp.stops() linearGradient = QLinearGradient(0.0, 50.0, 200.0, 50.0) for item in mStops: linearGradient.setColorAt(item.offset, item.color) linearGradient.setSpread(QGradient.PadSpread) svgName = os.path.join(os.path.dirname(__file__), self.text() + '.svg') pix = QSvgGenerator() pix.setFileName(svgName) pix.setSize(QSize(200, 100)) painter = QPainter() painter.begin(pix) br = QBrush(linearGradient) painter.setBrush(br) painter.drawRect(QRect(0, 0, 200, 100)) painter.end() pixmap = QPixmap(svgName) icon = QIcon(pixmap) self.svgName = svgName return icon
def paintEvent(self, ev): color = self.palette().color(QPalette.Highlight) painter = QPainter(self) # Filled rectangle. painter.setClipRect(self.rect()) color.setAlpha(50) painter.fillRect(self.rect().adjusted(2,2,-2,-2), color) # Thin rectangle outside. color.setAlpha(150) painter.setPen(color) painter.drawRect(self.rect().adjusted(0,0,-1,-1)) # Pseudo-handles at the corners and sides color.setAlpha(100) pen = QPen(color) pen.setWidth(8) painter.setPen(pen) painter.setBackgroundMode(Qt.OpaqueMode) # Clip at 4 corners region = QRegion(QRect(0,0,20,20)) region += QRect(self.rect().width()-20, 0, 20, 20) region += QRect(self.rect().width()-20, self.rect().height()-20, 20, 20) region += QRect(0, self.rect().height()-20, 20, 20) # Clip middles region += QRect(0, self.rect().height()/2-10, self.rect().width(), 20) region += QRect(self.rect().width()/2-10, 0, 20, self.rect().height()) # Draw thicker rectangles, clipped at corners and sides. painter.setClipRegion(region) painter.drawRect(self.rect())
def paintEvent(self, event): if not self.text().isEmpty(): painter = QPainter() painter.begin(self) painter.setRenderHint(QPainter.Antialiasing) color = self.palette().color(QPalette.Highlight) color.setAlpha(127) painter.setBrush(QBrush(color)) color = self.palette().color(QPalette.HighlightedText) color.setAlpha(127) painter.setPen(QPen(color)) size = self.height() / 2.0 left = self.width() - 4 painter.drawRect(left - size, size * 0.5, size, size) painter.drawLine(left - size * 0.75, size * 0.75, left - size * 0.25, size * 1.25) painter.drawLine(left - size * 0.25, size * 0.75, left - size * 0.75, size * 1.25) painter.end() QLabel.paintEvent(self, event)
def paintEvent(self, e): painter = QPainter(self) painter.setPen(QColor(self._backgroundColor)) painter.setBrush(QColor(self._backgroundColor)) painter.drawRect(0, 0, self.width(), self.height()) painter.end() QFrame.paintEvent(self, e)
def paintEvent(self, event): if not self.tenant: return paint = QPainter(self) for e in self.tenant.edges: if e == self.selectedEdge: paint.setPen(self.colors["selected"]) else: paint.setPen(self.colors["line"]) self.drawArrow(paint, self.vertices[e.e1].x() + self.size / 2, self.vertices[e.e1].y() + self.size / 2, self.vertices[e.e2].x() + self.size / 2, self.vertices[e.e2].y() + self.size / 2) for v in self.vertices.keys(): pen = paint.pen() paint.setPen(Qt.red) if self.selectedVertex == self.vertices[v]: paint.drawRect(self.vertices[v]) if isinstance(v, VM): paint.drawImage(self.vertices[v], self.computericon) elif isinstance(v, Storage): paint.drawImage(self.vertices[v], self.storageicon) elif isinstance(v, NetElement): if v.router: paint.drawImage(self.vertices[v], self.routericon) else: paint.drawImage(self.vertices[v], self.switchicon) elif isinstance(v, Vnf): paint.drawImage(self.vertices[v], self.serviceicon) elif isinstance(v, Domain): paint.drawImage(self.vertices[v], self.domainicon) paint.setPen(self.colors["line"]) if self.edgeDraw: self.drawArrow(paint, self.curEdge[0].x() + self.size / 2, self.curEdge[0].y() + self.size / 2, QCursor.pos().x() - self.mapToGlobal(self.geometry().topLeft()).x(), QCursor.pos().y() - self.mapToGlobal(self.geometry().topLeft()).y()) paint.end()
def paintEvent(self, event): painter = QPainter() painter.begin(self) if not self.showRegionMap: painter.drawPixmap(0, 0, self.scaledOwnershipMap) rect = self.imageRect() if self.isEnabled(): if self.showRegionMap: painter.drawPixmap(0, 0, self.scaledRegionMap) else: if self.currentTerritory: painter.drawPixmap(0, 0, self.coloredMask(self.currentTerritory, QColor(*self.game.clientPlayer.color))) #draw active animations for a in self.animations: painter.save() a.paint(painter) painter.restore() painter.drawPixmap(0, 0, self.scaledTroopCountMap) else: painter.fillRect(rect, QColor(0, 0, 0, 200)) painter.drawText(rect, Qt.AlignCenter, "Waiting for the game to start.") #remaining troops if self.game.yourTurn() and self.game.remainingTroops: troopText = "Remaining troops: %d" % self.game.remainingTroops troopRect = QRect(0, 0, painter.fontMetrics().width(troopText) + 8, painter.fontMetrics().height() + 8) troopRect.moveBottomLeft(rect.bottomLeft()) painter.setPen(Qt.white) painter.setBrush(QColor(0, 0, 0, 200)) painter.drawRect(troopRect) painter.drawText(troopRect, Qt.AlignCenter, troopText) painter.end()
def drawBox(self): '''handle errors''' if not self.pixmap: self.showErrMsg('Please choose an image first!') return x, y, w, h = self.line_x.text(), self.line_y.text(), self.line_w.text(),\ self.line_h.text() if not (x.isdigit() and y.isdigit() and w.isdigit() and h.isdigit()): self.showErrMsg('Please input integer!') return x, y, w, h = int(x), int(y), int(w), int(h) if not 0 <= x <= self.pixmap.width(): self.showErrMsg('Value Error', 'x should be an integer between 0 and %d' % self.pixmap.width()) elif not 0 <= y <= self.pixmap.height(): self.showErrMsg('Value Error', 'y should be an integer between 0 and %d' % self.pixmap.height()) elif not 0 <= w <= (self.pixmap.width() - x): self.showErrMsg('Value Error', 'x + w should be an integer between 0 and %d' % self.pixmap.width()) elif not 0 <= h <= (self.pixmap.height() - y): self.showErrMsg('Value Error', 'y + h should be an integer between 0 and %d' % self.pixmap.height()) else: painter = QPainter() painter.begin(self.pixmap) pen = QPen(QtCore.Qt.red, 5, QtCore.Qt.SolidLine) painter.setPen(pen) painter.drawRect(x, y, w, h) painter.end() self.labelImage.setPixmap(self.pixmap)
def _paint_bg(self, p: QPainter): dpi = Info.dpi pen = self.pen() p.setRenderHint(QPainter.Antialiasing, True) p.setPen(pen) p.setBrush(self.bg()) p.drawRoundedRect(OIBlock.padding * dpi, OIBlock.padding * dpi, self.width() - 2 * OIBlock.padding * dpi, self.height() - 2 * OIBlock.padding * dpi, OIBlock.radius * dpi, OIBlock.radius * dpi) p.setBrush(self.title_bg()) p.drawRoundedRect(OIBlock.padding * dpi, OIBlock.padding * dpi, self.width() - 2 * OIBlock.padding * dpi, .35 * dpi + OIBlock.padding * dpi, OIBlock.radius * dpi, OIBlock.radius * dpi) p.setBrush(self.bg()) p.setPen(QColor(0, 0, 0, 0)) p.drawRect(0.01 * dpi + OIBlock.padding * dpi, 0.35 * dpi + OIBlock.padding * dpi, self.width() - 0.02 * dpi - 2 * OIBlock.padding * dpi, 0.10 * dpi) p.setPen(pen) if self._resizable: if self.__corner_path is None: self.__init_corner() p.setBrush(pen.brush()) p.drawPath( self.__corner_path.translated(self.width(), self.height()))
def drawROIBoxes(self, image): #print(self.frame_data) if not isinstance(self.frame_data, pd.DataFrame) or len(self.frame_data) == 0 \ or not self.label_type in self.frame_data: return self.img_h_ratio = image.height()/self.image_height; self.img_w_ratio = image.width()/self.image_width; painter = QPainter() painter.begin(image) for row_id, row_data in self.frame_data.iterrows(): x = row_data['coord_x']*self.img_h_ratio y = row_data['coord_y']*self.img_w_ratio #check if the coordinates are nan if not (x == x) or not (y == y): continue x = int(x) y = int(y) c = self.wlabC[int(row_data[self.label_type])] painter.setPen(c) painter.setFont(QFont('Decorative', 10)) painter.drawText(x, y, str(int(row_data[self.worm_index_type]))) bb = row_data['roi_size']*self.img_w_ratio painter.drawRect(x-bb/2, y-bb/2, bb, bb); painter.end()
def paintEvent(self, event): super(DetailedProgress, self).paintEvent(event) if not self._current_progress: return painter = QPainter(self) width = self.width() height = self.height() aspect_ratio = float(width)/height nr_realizations = len(self._current_progress) fm_size = len(self._current_progress[0][1]) self.grid_height = math.ceil(math.sqrt(nr_realizations / aspect_ratio)) self.grid_width = math.ceil(self.grid_height * aspect_ratio) sub_grid_size = math.ceil(math.sqrt(fm_size)) cell_height = height / self.grid_height cell_width = width / self.grid_width foreground_image = QImage(self.grid_width*sub_grid_size, self.grid_height*sub_grid_size, QImage.Format_ARGB32) foreground_image.fill(QColor(0, 0, 0, 0)) for index, (iens, progress) in enumerate(self._current_progress): y = int(iens / self.grid_width) x = int(iens - (y * self.grid_width)) self.draw_window(x * sub_grid_size, y * sub_grid_size, progress, foreground_image) painter.drawImage(self.contentsRect(), foreground_image) for index, (iens, progress) in enumerate(self._current_progress): y = int(iens / self.grid_width) x = int(iens - (y * self.grid_width)) if iens == self.selected_realization: painter.setPen(QColor(240, 240, 240)) else: painter.setPen(QColor(80, 80, 80)) painter.drawRect(x * cell_width, y * cell_height, cell_width-1, cell_height-1) painter.drawText(x * cell_width + cell_width / 2, y * cell_height + cell_height / 2, str(iens))
def paintEvent( self, event ): """ Overloads the paint event for this menu to draw its title based on its \ show title property. :param event | <QPaintEvent> """ super(XMenu, self).paintEvent(event) if ( self.showTitle() ): painter = QPainter() painter.begin(self) palette = self.palette() painter.setBrush(palette.color(palette.Button)) painter.setPen(Qt.NoPen) painter.drawRect(1, 1, self.width() - 2, 22) painter.setBrush(Qt.NoBrush) painter.setPen(palette.color(palette.ButtonText)) painter.drawText(1, 1, self.width() - 2, 22, Qt.AlignCenter, self.title()) painter.end()
def drawROIBoxes(self, image): #print(self.frame_data) if not isinstance(self.frame_data, pd.DataFrame) or len(self.frame_data) == 0 \ or not self.label_type in self.frame_data: return self.img_h_ratio = image.height() / self.image_height self.img_w_ratio = image.width() / self.image_width painter = QPainter() painter.begin(image) for row_id, row_data in self.frame_data.iterrows(): x = row_data['coord_x'] * self.img_h_ratio y = row_data['coord_y'] * self.img_w_ratio #check if the coordinates are nan if not (x == x) or not (y == y): continue x = int(x) y = int(y) c = self.wlabC[int(row_data[self.label_type])] painter.setPen(c) painter.setFont(QFont('Decorative', 10)) painter.drawText(x, y, str(int(row_data[self.worm_index_type]))) bb = row_data['roi_size'] * self.img_w_ratio painter.drawRect(x - bb / 2, y - bb / 2, bb, bb) 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 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, 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.0 * 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): qp = QPainter(self) qp.setBrush(QBrush(self.color)) qp.setPen(self.color) qp.drawRect(0, 0, 25, 25) qp.setBrush(Qt.NoBrush) qp.setPen(Qt.black) qp.drawRect(1, 1, 24, 24)
def __setProgressPixmapInactive(self, pixmap): alpha = pixmap.alphaChannel() painter = QPainter() painter.begin(alpha) painter.setBrush(QBrush(QColor(0, 0, 0, 196))) painter.drawRect(pixmap.rect()) painter.end() pixmap.setAlphaChannel(alpha)
def paintEvent(self,event): titleHeight = 40 bottomHeight = 50 #画标题背景 painter = QPainter(self) painter.save() linearGradient = QLinearGradient(0, 0,0,titleHeight) linearGradient.setColorAt(0, QColor(60,150,255)) linearGradient.setColorAt(0.1, QColor(6,88,200)) linearGradient.setColorAt(1, QColor(80,150,255)) painter.setBrush(QBrush(linearGradient)) contenRect = QRect(0, 0, self.width(), titleHeight) painter.fillRect(contenRect, QBrush(linearGradient)) painter.restore() #画标题内容 painter.save() painter.setPen(QPen(QColor(255, 255, 255),1)) font = painter.font() font.setPointSize(12) painter.setFont(font) painter.drawText(QPoint(10,25), self.title) painter.restore() #画中间白色背景 painter.save() painter.setPen(QPen(QColor(255, 255, 255),1)) brush = QBrush(QColor(242,242,242)) painter.setBrush(brush) contenRect = QRect(0, titleHeight, self.width()-1, self.height() - titleHeight - bottomHeight) # painter.fillRect(contenRect, brush) painter.drawRect(contenRect) painter.restore() #画提示信息内容 painter.save() painter.setPen(QPen(QColor(1, 1, 1),1)) font = painter.font() font.setPointSize(15) painter.setFont(font) fm = QFontMetrics(font) infoWidth = fm.width(self.hintInfo) painter.drawText(QPoint((self.width() - infoWidth - 10)/2, 150), self.hintInfo) painter.restore() #画底层背景 painter.save() brush = QBrush(QColor(219,234,255)) painter.setBrush(brush) contenRect = QRect(0, self.height() - bottomHeight, self.width(), bottomHeight) painter.fillRect(contenRect, brush) painter.restore()
def prepare_pixmap(image, c): pixmap = QPixmap.fromImage(image) painter = QPainter() painter.begin(pixmap) painter.drawRect(QRect(c.sub_image_anchor_px, c.sub_image_anchor_px, c.sub_image_pxs, c.sub_image_pxs)) # draw center square painter.drawRect(QRect(0, 0, c.display_image_edge_pxs, c.display_image_edge_pxs)) # draw border painter.end() return pixmap
def paintEvent(self, event): super(DetailedProgress, self).paintEvent(event) if not self._current_progress: return painter = QPainter(self) width = self.width() height = self.height() aspect_ratio = float(width) / height nr_realizations = max([iens for iens, _, _ in self._current_progress]) + 1 fm_size = max( [len(progress) for _, progress, _ in self._current_progress]) self.grid_height = math.ceil(math.sqrt(nr_realizations / aspect_ratio)) self.grid_width = math.ceil(self.grid_height * aspect_ratio) sub_grid_size = math.ceil(math.sqrt(fm_size)) cell_height = height / self.grid_height cell_width = width / self.grid_width foreground_image = QImage(self.grid_width * sub_grid_size, self.grid_height * sub_grid_size, QImage.Format_ARGB32) foreground_image.fill(QColor(0, 0, 0, 0)) for index, (iens, progress, _) in enumerate(self._current_progress): y = int(iens / self.grid_width) x = int(iens - (y * self.grid_width)) self.draw_window(x * sub_grid_size, y * sub_grid_size, progress, foreground_image) painter.drawImage(self.contentsRect(), foreground_image) for index, (iens, progress, state) in enumerate(self._current_progress): y = int(iens / self.grid_width) x = int(iens - (y * self.grid_width)) painter.setPen(QColor(80, 80, 80)) painter.drawText(x * cell_width, y * cell_height, cell_width, cell_height, Qt.AlignHCenter | Qt.AlignVCenter, str(iens)) if iens == self.selected_realization: pen = QPen(QColor(240, 240, 240)) elif (self.has_realization_failed(progress)): pen = QPen(QColor(*self.state_colors['Failure'])) elif (state == JobStatusType.JOB_QUEUE_RUNNING): pen = QPen(QColor(*self.state_colors['Running'])) else: pen = QPen(QColor(80, 80, 80)) thickness = 4 pen.setWidth(thickness) painter.setPen(pen) painter.drawRect((x * cell_width) + (thickness / 2), (y * cell_height) + (thickness / 2), cell_width - (thickness - 1), cell_height - (thickness - 1))
def paintEvent(self, event): painter = QPainter(self) width = self.width() height = self.height() if self.scales_visible: curve_width = width - self.y_scale.total_width - self.curve_to_scale - self.curve_outer_border curve_height = height - self.y_scale_height_offset - self.x_scale.total_height - self.curve_to_scale else: curve_width = width - self.curve_outer_border - self.curve_outer_border curve_height = height - self.curve_outer_border - self.curve_outer_border if DEBUG: painter.fillRect(0, 0, width, height, Qt.green) # fill canvas if self.scales_visible: canvas_x = self.y_scale.total_width + self.curve_to_scale - self.curve_outer_border canvas_y = self.y_scale_height_offset - self.curve_outer_border else: canvas_x = 0 canvas_y = 0 canvas_width = self.curve_outer_border + curve_width + self.curve_outer_border canvas_height = self.curve_outer_border + curve_height + self.curve_outer_border painter.fillRect(canvas_x, canvas_y, canvas_width, canvas_height, self.canvas_color) # draw canvas border if self.curve_outer_border > 0: painter.setPen(QColor(190, 190, 190)) painter.drawRect( canvas_x, canvas_y, canvas_width - 1, canvas_height - 1 ) # -1 to accommodate the 1px width of the border painter.setPen(Qt.black) if DEBUG: painter.fillRect( canvas_x + self.curve_outer_border, canvas_y + self.curve_outer_border, curve_width, curve_height, Qt.cyan, ) # draw scales if self.scales_visible: y_min_scale = self.y_scale.value_min y_max_scale = self.y_scale.value_max factor_x = float(curve_width) / self.history_length_x factor_y = float(curve_height - 1) / max( y_max_scale - y_min_scale, EPSILON ) # -1 to accommodate the 1px width of the curve self.draw_x_scale(painter, factor_x) self.draw_y_scale(painter, curve_height, factor_y)
def paintEvent(self, _): """ :type _: QPaintEvent """ painter = QPainter(self) painter.setBrush(QBrush(self.__rect_color)) painter.setPen(QPen(self.__rect_color)) painter.drawRect(self.__drag_and_drop_rect)
def paintEvent(self, e): painter = QPainter(self) painter.setBrush(self._base) if self.selected: painter.pen().setColor(QColor('yellow')) else: painter.pen().setColor(self._base.dark(150)) painter.pen().setWidth(self.margin) painter.drawRect(0, 0, self.width(), self.height())
def paintEvent(self, event ): if self.pendingMessageCount() == 0 : QWidget.paintEvent(self, event ) return painter = QPainter( self ) painter.setPen( Qt.NoPen ) painter.setBrush( self.currentMessageBackground() ) painter.drawRect( self.contentsRect() )
def paintEvent(self, event): qp = QPainter() qp.begin(self) qp.setBrush(self.gradient) qp.setPen(Qt.transparent) qp.drawRect(0, 0, self.SIZE_X, self.SIZE_Y) qp.setBrush(QBrush(Qt.red)) qp.setPen(Qt.red) qp.drawLine(0, self.reflectivity, self.SIZE_X, self.reflectivity) qp.end()
def paintEvent(self, e): if self.active: painter = QPainter(self) pen = painter.pen() pen.setWidth(self.margin) pen.setColor(self.frame_color) color = QColor(self.frame_color) color.setAlpha(30) painter.setBrush(color) painter.drawRect(0, 0, self.width(), self.height())
def paintEvent(self, event): qp = QPainter() qp.begin(self) qp.setBrush(QBrush(self.color)) qp.setPen(self.color) qp.drawRect(0, 0, 15, 15) qp.setBrush(Qt.NoBrush) qp.setPen(Qt.black) qp.drawRect(1, 1, 14, 14) qp.end()
def paintEvent(self, event ): if self._queuedWidget.pendingMessageCount() == 0 : QToolBar.paintEvent( self, event ) return brush = self._queuedWidget.currentMessageBackground() painter = QPainter( self ) painter.setPen( brush.color().darker( 150 ) ) painter.setBrush( brush ) painter.drawRect( self.contentsRect().adjusted( 0, 0, -1, -1 ) )
def paintEvent(self, event=None): font = QFont(self.font()) font.setPointSize(font.pointSize() - 1) fm = QFontMetricsF(font) fracWidth = fm.width(FractionSlider.WSTRING) indent = fm.boundingRect("9").width() / 2.0 if not X11: fracWidth *= 1.5 span = self.width() - (FractionSlider.XMARGIN * 2) value = self.__numerator / float(self.__denominator) painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing) painter.setRenderHint(QPainter.TextAntialiasing) painter.setPen(self.palette().color(QPalette.Mid)) painter.setBrush(self.palette().brush( QPalette.AlternateBase)) painter.drawRect(self.rect()) segColor = QColor(Qt.green).dark(120) segLineColor = segColor.dark() painter.setPen(segLineColor) painter.setBrush(segColor) painter.drawRect(FractionSlider.XMARGIN, FractionSlider.YMARGIN, span, fm.height()) textColor = self.palette().color(QPalette.Text) segWidth = span / self.__denominator segHeight = fm.height() * 2 nRect = fm.boundingRect(FractionSlider.WSTRING) x = FractionSlider.XMARGIN yOffset = segHeight + fm.height() for i in range(self.__denominator + 1): painter.setPen(segLineColor) painter.drawLine(x, FractionSlider.YMARGIN, x, segHeight) painter.setPen(textColor) y = segHeight rect = QRectF(nRect) rect.moveCenter(QPointF(x, y + fm.height() / 2.0)) painter.drawText(rect, Qt.AlignCenter, QString.number(i)) y = yOffset rect.moveCenter(QPointF(x, y + fm.height() / 2.0)) painter.drawText(rect, Qt.AlignCenter, QString.number(self.__denominator)) painter.drawLine(QPointF(rect.left() + indent, y), QPointF(rect.right() - indent, y)) x += segWidth span = int(span) y = FractionSlider.YMARGIN - 0.5 triangle = [QPointF(value * span, y), QPointF((value * span) + (2 * FractionSlider.XMARGIN), y), QPointF((value * span) + FractionSlider.XMARGIN, fm.height())] painter.setPen(Qt.yellow) painter.setBrush(Qt.darkYellow) painter.drawPolygon(QPolygonF(triangle))
def __add_black_border_(self, pixmap): """Add a black border around a pixmap @param pixmap: The pixmap @type pixmap: QPixmap """ painter = QPainter() painter.begin(pixmap) painter.setPen(Qt.black); painter.drawRect(QRect(0, 0, pixmap.width() - 1, pixmap.height() - 1)) painter.end()
def paintEvent(self, event): painter = QPainter(self) width = self.width() height = self.height() if self.scales_visible: curve_width = width - self.y_scale.total_width - self.curve_to_scale - self.curve_outer_border curve_height = height - self.y_scale_height_offset - self.x_scale.total_height - self.curve_to_scale else: curve_width = width - self.curve_outer_border - self.curve_outer_border curve_height = height - self.curve_outer_border - self.curve_outer_border if DEBUG: painter.fillRect(0, 0, width, height, Qt.green) # fill canvas if self.scales_visible: canvas_x = self.y_scale.total_width + self.curve_to_scale - self.curve_outer_border canvas_y = self.y_scale_height_offset - self.curve_outer_border else: canvas_x = 0 canvas_y = 0 canvas_width = self.curve_outer_border + curve_width + self.curve_outer_border canvas_height = self.curve_outer_border + curve_height + self.curve_outer_border painter.fillRect(canvas_x, canvas_y, canvas_width, canvas_height, self.canvas_color) # draw canvas border if self.curve_outer_border > 0: painter.setPen(QColor(190, 190, 190)) painter.drawRect( canvas_x, canvas_y, canvas_width - 1, canvas_height - 1) # -1 to accommodate the 1px width of the border painter.setPen(Qt.black) if DEBUG: painter.fillRect(canvas_x + self.curve_outer_border, canvas_y + self.curve_outer_border, curve_width, curve_height, Qt.cyan) # draw scales if self.scales_visible: y_min_scale = self.y_scale.value_min y_max_scale = self.y_scale.value_max factor_x = float(curve_width) / self.x_diff factor_y = float(curve_height - 1) / max( y_max_scale - y_min_scale, EPSILON) # -1 to accommodate the 1px width of the curve self.draw_x_scale(painter, curve_width, factor_x) self.draw_y_scale(painter, curve_height, factor_y)
def drawPixmapForUnckecked(self): self.pixmapUnckecked = QPixmap(self.itemWidth, self.itemHeight) self.pixmapUnckecked.fill(Qt.transparent) painter = QPainter() painter.begin(self.pixmapUnckecked) painter.setRenderHint(QPainter.Antialiasing) pen = QPen() pen.setWidth(2) painter.setPen(pen) painter.drawRect(QRect(5,5,self.itemWidth-10, self.itemHeight-10)) painter.end()
def paintEvent(self, paintevent): """Paints the box""" painter = QPainter(self) rect = self.contentsRect() rect.setWidth(rect.width() - 1) rect.setHeight(rect.height() - 1) painter.drawRect(rect) rect.setX(rect.x() + 1) rect.setY(rect.y() + 1) painter.fillRect(rect, self._getColor())
def updateColor(self): iconSize = self.iconSize() width = iconSize.width() height = iconSize.height() pixmap = QPixmap(iconSize) pixmap.fill(self._color) painter = QPainter() painter.begin(pixmap) painter.setPen(QPen(QColor("#777777"))) painter.drawRect(QRect(0, 0, width - 1, height - 1)) painter.end() self.setIcon(QIcon(pixmap))
def palette_pixmap(colors, size): img = QPixmap(size) img.fill(Qt.transparent) painter = QPainter(img) grad = palette_gradient(colors) grad.setCoordinateMode(QLinearGradient.ObjectBoundingMode) painter.setPen(Qt.NoPen) painter.setBrush(QBrush(grad)) painter.drawRect(0, 0, size.width(), size.height()) painter.end() return img
def drawRectangle(self, x=0, y=0, w=0, h=0): """ Draw a rectangle """ self.mobileImageLabel.update() pixmap = self.mobileImageLabel.pixmap() if pixmap is not None: p = QPainter(pixmap) pen = QPen(Qt.red, 2, Qt.SolidLine) p.setPen(pen) p.drawRect(x, y, w, h) p.end()
def paintEvent(self, event): painter = QPainter(self) painter.fillRect(event.rect(), self.__background_color) # Draw markers self.__draw_markers(painter) # Draw slider if settings.DOCMAP_SLIDER and self.__scrollbar.isVisible(): painter.setPen(Qt.NoPen) color = QColor(Qt.lightGray) color.setAlpha(50) painter.setBrush(QBrush(color)) position1 = self.__get_position(self.__scrollbar.value()) position2 = self.__get_position(self.__scrollbar.value() + self.__scrollbar.pageStep()) painter.drawRect(0, position1, self.__width, position2 - position1)
def paintEvent(self, event): """ Handles the drawing for this widget and its selection region. :param event | <QPaintEvent> """ pen = QPen(Qt.DashLine) pen.setColor(QColor('red')) painter = QPainter(self) painter.setPen(pen) clr = QColor('black') clr.setAlpha(100) painter.setBrush(clr) painter.drawRect(self._region)
def grab_svg(scene): """ Return a SVG rendering of the scene contents. Parameters ---------- scene : :class:`CanvasScene` """ from PyQt4.QtSvg import QSvgGenerator svg_buffer = QBuffer() gen = QSvgGenerator() gen.setOutputDevice(svg_buffer) items_rect = scene.itemsBoundingRect().adjusted(-10, -10, 10, 10) if items_rect.isNull(): items_rect = QRectF(0, 0, 10, 10) width, height = items_rect.width(), items_rect.height() rect_ratio = float(width) / height # Keep a fixed aspect ratio. aspect_ratio = 1.618 if rect_ratio > aspect_ratio: height = int(height * rect_ratio / aspect_ratio) else: width = int(width * aspect_ratio / rect_ratio) target_rect = QRectF(0, 0, width, height) source_rect = QRectF(0, 0, width, height) source_rect.moveCenter(items_rect.center()) gen.setSize(target_rect.size().toSize()) gen.setViewBox(target_rect) painter = QPainter(gen) # Draw background. painter.setBrush(QBrush(Qt.white)) painter.drawRect(target_rect) # Render the scene scene.render(painter, target_rect, source_rect) painter.end() buffer_str = str(svg_buffer.buffer()) return unicode(buffer_str.decode("utf-8"))
def drawPixmapForPartiallyChecked(self): self.pixmapPartiallyChecked = QPixmap(self.itemWidth, self.itemHeight) self.pixmapPartiallyChecked.fill(Qt.transparent) painter = QPainter() painter.begin(self.pixmapPartiallyChecked) painter.setRenderHint(QPainter.Antialiasing) pen = QPen() pen.setWidth(2) painter.setPen(pen) painter.drawRect(QRect(5,5,self.itemWidth-10, self.itemHeight-10)) pen.setWidth(4) pen.setColor(QColor(139,137,137)) painter.setPen(pen) painter.drawLine(self.itemWidth/2-5, self.itemHeight/2, self.itemWidth/2, self.itemHeight-9) painter.drawLine(self.itemWidth/2, self.itemHeight-9, self.itemWidth/2+10, 2) painter.end()
def _paint_bg(self, p: QPainter): pen = Block.selected_pen if self.__selected else Block.border_pen p.setRenderHint(QPainter.Antialiasing, True) p.setPen(pen) p.setBrush(self.bg()) p.drawRoundedRect(Block.padding, Block.padding, self.width() - 2 * Block.padding, self.height() - 2 * Block.padding, 8, 8) p.setBrush(self.title_bg()) p.drawRoundedRect(Block.padding, Block.padding, self.width() - 2 * Block.padding, 35 + Block.padding, 8, 8) p.setBrush(self.bg()) p.setPen(QColor(0, 0, 0, 0)) p.drawRect(1 + Block.padding, 35 + Block.padding, self.width() - 2 - 2 * Block.padding, 10) p.setPen(pen) if self._resizable: p.setBrush(pen.brush()) p.drawPath(self.__corner_path.translated(self.width(), self.height()))