def createPixmap(self):
"""Creates the pixmap shown when this label is dragged."""
font_metric = QFontMetrics(QFont())
text_size = font_metric.size(Qt.TextSingleLine, self.text)
image = QImage(text_size.width() + 4, text_size.height() + 4,
QImage.Format_ARGB32_Premultiplied)
image.fill(qRgba(240, 240, 120, 255))
painter = QPainter()
painter.begin(image)
painter.setFont(QFont())
painter.setBrush(Qt.black)
painter.drawText(QRect(QPoint(2, 2), text_size), Qt.AlignCenter,
self.text)
painter.end()
return image
def drawIconWithShadow(icon, rect, p, iconMode, radius, color, offset):
cache = QPixmap()
pixmapName = "icon {0} {1} {2}".format(icon.cacheKey(), iconMode, rect.height())
if not QPixmapCache.find(pixmapName, cache):
px = icon.pixmap(rect.size())
cache = QPixmap(px.size() + QSize(radius * 2, radius * 2))
cache.fill(Qt.transparent)
cachePainter = QPainter(cache)
if iconMode == QIcon.Disabled:
im = px.toImage().convertToFormat(QImage.Format_ARGB32)
for y in range(im.height()):
scanLine = im.scanLine(y)
for x in range(im.width()):
pixel = scanLine
intensity = qGray(pixel)
scanLine = qRgba(intensity, intensity, intensity, qAlpha(pixel))
scanLine += 1
px = QPixmap.fromImage(im)
# 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(QPoint(radius, radius), px)
tmpPainter.end()
# blur the alpha channel
blurred = QImage(tmp.size(), QImage.Format_ARGB32_Premultiplied)
blurred.fill(Qt.transparent)
blurPainter = QPainter(blurred)
# todo : blur image
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(QPoint(radius, radius) + offset, px)
QPixmapCache.insert(pixmapName, cache)
targetRect = cache.rect()
targetRect.moveCenter(rect.center())
p.drawPixmap(targetRect.topLeft() - offset, cache)
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.HighQualityAntialiasing)
painter.setRenderHint(QPainter.Antialiasing)
painter.setRenderHint(QPainter.SmoothPixmapTransform)
# change the look for on/off
if self.isChecked():
# blue fill
brush = QBrush(self.color1)
painter.setBrush(brush)
painter.drawRoundedRect(0, 7, self.width() - 2, self.height() - 15, self.height() / 2 - 10,
self.height() / 2)
brush = QBrush(self.lighter(self.color1))
painter.setBrush(brush)
painter.drawEllipse(self.width() - self.height(), 0, self.height(), self.height())
else:
# gray fill
brush = QBrush(self.color2)
painter.setBrush(brush)
painter.drawRoundedRect(1, 7, self.width() - 3, self.height() - 15, self.height() / 2 - 10,
self.height() / 2)
brush = QBrush(QColor(100, 100, 100))
painter.setBrush(brush)
painter.drawEllipse(0, 0, self.height(), self.height())
painter.end()
def paintEvent(self, e):
painter = QPainter()
painter.begin(self)
width = self.width()
height = self.height()
#Blank out the world
painter.fillRect(0, 0, width, height, Qt.white)
#Compute width/height of the columns and rows
#Reserve pixels for the grid lines
colWidth = (width - (self._NUM_COLS - 1) * self._GRID_SIZE) / self._NUM_COLS
rowHeight = (height - (self._NUM_ROWS - 1) * self._GRID_SIZE) / self._NUM_ROWS
colWidth = max(1, colWidth)
rowHeight = max(1, rowHeight)
#Perform drawing operations for world rendering
self._drawGrid(width, height, colWidth, rowHeight, painter)
self._drawObstacles(colWidth, rowHeight, painter)
if self._drawVisited:
self._drawVisitedCells(colWidth, rowHeight, painter)
if self._drawActive:
self._drawActiveCells(colWidth, rowHeight, painter)
self._drawStartAndEndCells(colWidth, rowHeight, painter)
self._drawCurrentCell(colWidth, rowHeight, painter)
if self._drawCheapestPath:
self._drawPath(colWidth, rowHeight, painter)
painter.end()
class View(QMainWindow, Ui_MainWindow):
points = []
def __init__(self):
super().__init__()
self.setupUi(self)
self.show()
self.painter = QPainter()
def paintEvent(self, event):
self.painter.begin(self)
for p in self.points:
self.painter.setPen(QColor(p.clr[0], p.clr[1], p.clr[2]))
self.painter.drawEllipse(p.x.value, p.y.value, p.rad.value,
p.rad.value)
self.painter.end()
def resizeEvent(self, event):
for p in self.points:
p.resize(self.canvas.size().width(), self.canvas.size().height())
def closeEvent(self, event):
for p in self.points:
p.join()
event.accept()
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.HighQualityAntialiasing)
painter.setRenderHint(QPainter.Antialiasing)
painter.setRenderHint(QPainter.SmoothPixmapTransform)
# change the look for on/off
if self.isChecked():
# blue fill
brush = QBrush(self.color1)
painter.setBrush(brush)
painter.drawRoundedRect(0, 7,
self.width() - 2,
self.height() - 15,
self.height() / 2 - 10,
self.height() / 2)
brush = QBrush(self.lighter(self.color1))
painter.setBrush(brush)
painter.drawEllipse(self.width() - self.height(), 0, self.height(),
self.height())
else:
# gray fill
brush = QBrush(self.color2)
painter.setBrush(brush)
painter.drawRoundedRect(1, 7,
self.width() - 3,
self.height() - 15,
self.height() / 2 - 10,
self.height() / 2)
brush = QBrush(QColor(100, 100, 100))
painter.setBrush(brush)
painter.drawEllipse(0, 0, self.height(), self.height())
painter.end()
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.save()
self.rect = painter.viewport()
self.rect.adjust(0, 0, -1, -1)
painter.drawRect(QRectF(self.rect))
self.prj.setupPrism(self.rect.height(), 68)
self.prj.setupProjectionMatrix(self.alef, self.bet)
# draw the prism
self.drawCubick(painter, [0, 0, 0], 63, 16)
mineCube = self.parent.presenter.mineCube
for y in range(len(mineCube)):
for z in range(len(mineCube[0])):
for x in range(len(mineCube[0][0])):
if mineCube[y][z][x] in self.parent.selectedMinerals.list_:
colo = self.parent.selectedMinerals.\
getColor(mineCube[y][z][x])
self.drawCubick(painter, [x, y, z], color=colo)
self.drawSliceCursor(painter, self.parent.presenter.elevation)
painter.restore()
painter.end()
del painter
def paintEvent(self, event):
qp = QPainter()
qp.begin(self)
qp.setRenderHint(QPainter.Antialiasing)
self._draw_rim(event, qp)
self._draw_slices(event, qp)
self._draw_indicator(event, qp)
qp.end()
def paint(self, painter, option, widget=None):
painter_inverted = QPainter()
brect= QGraphicsProxyWidget.boundingRect(self)
invertedColor = QImage(brect.width(),brect.height(),QImage.Format_RGB32)
painter_inverted.begin(invertedColor)
QGraphicsProxyWidget.paint(self,painter_inverted, option, widget)
painter_inverted.end()
painter.drawImage(0,0,invertedColor.rgbSwapped())
def paintEvent(self, event):
qp = QPainter()
qp.begin(self)
qp.setRenderHint(QPainter.Antialiasing)
self._draw_rim(event, qp)
self._draw_slices(event, qp)
self._draw_indicator(event, qp)
qp.end()
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
self.drawWidget(painter)
painter.end()
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.HighQualityAntialiasing)
painter.setRenderHint(QPainter.Antialiasing)
painter.setRenderHint(QPainter.SmoothPixmapTransform)
painter.setBrush(QColor(self.color))
painter.drawRect(self.window().x() + 4, self.window().y() + 4, self.window().width(), self._height)
painter.end()
def paintEvent(self, event):
text = []
text.append(['{0}; {1}'.format(self.parent.chunkData['X'], self.parent.chunkData['Y']), Qt.black])
if self.parent.chunkData[14] > 0:
text.append(['Gold = {0}'.format(self.parent.chunkData[14]), Qt.yellow])
else:
text.append(['', Qt.yellow])
if self.parent.chunkData[15] > 0:
text.append(['Iron = {0}'.format(self.parent.chunkData[15]), Qt.red])
else:
text.append(['', Qt.red])
if self.parent.chunkData[56] > 0:
text.append(['Diamond = {0}'.format(self.parent.chunkData[56]), Qt.cyan])
else:
text.append(['', Qt.cyan])
if self.parent.chunkData[73] > 0:
text.append(['Redstone = {0}'.format(self.parent.chunkData[73]), Qt.magenta])
else:
text.append(['', Qt.magenta])
if self.parent.chunkData[49] > 0:
text.append(['Obsidian = {0}'.format(self.parent.chunkData[49]), Qt.darkYellow])
else:
text.append(['', Qt.darkYellow])
if self.parent.chunkData[21] > 0:
text.append(['Lazurit = {0}'.format(self.parent.chunkData[21]), Qt.darkBlue])
else:
text.append(['', Qt.darkBlue])
painter = QPainter()
painter.begin(self)
painter.drawRect(self.parent.leftMargin, self.parent.topMargin,
self.edgeLen, self.edgeLen)
cX = self.parent.leftMargin + self.parent.vsepara
cY = self.parent.topMargin + self.parent.hsepara
alig = Qt.AlignCenter
i = 0
fontik = painter.font()
for t in text:
if i > 0:
alig = Qt.AlignLeft
painter.setPen(t[1])
if i == 2:
fontik.setUnderline(True)
else:
fontik.setUnderline(False)
painter.setFont(fontik)
painter.drawText(cX, cY, self.tBoxWidth, self.tBoxHeight, alig, t[0])
cY += self.lineSpacing
i += 1
painter.end()
del painter
def paintEvent(self, event): painter = QPainter() painter.begin(self) self.theme.render(painter, "kdiamond-" + self.color) if self.selected: self.theme.render(painter, "kdiamond-selection") painter.end()
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.HighQualityAntialiasing)
painter.setRenderHint(QPainter.Antialiasing)
painter.setRenderHint(QPainter.SmoothPixmapTransform)
painter.setBrush(QColor(self.color))
painter.drawRect(self.window().x() + 4,
self.window().y() + 4,
self.window().width(), self._height)
painter.end()
def paintEvent(self, e):
''' overwrite paintEvent in order to also redraw points (indicating
electrode positions) and their link to added plots
this is necessary to get smooth animation if plots are dragged around
'''
super(DragWindow, self).paintEvent(e)
qp = QPainter()
qp.begin(self)
self.drawPoints(qp)
qp.end()
def paintEvent(self, evt):
# print 'paint', self.color, self.text(), self.width(), self.height(), evt.rect().width()
qp = QPainter()
qp.begin(self)
qp.setBrush(QColor('#{}'.format(self.color[:-2])))
qp.drawRect(0, 0, self.width(), self.height())
qp.end()
qp.begin(self)
qp.setPen(self._get_text_color())
qp.drawText(evt.rect(), QtCore.Qt.AlignCenter, self.text())
qp.end()
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.HighQualityAntialiasing)
painter.setRenderHint(QPainter.Antialiasing)
painter.setRenderHint(QPainter.SmoothPixmapTransform)
painter.setBrush(self.color)
if self.effect_size == self.radius:
painter.drawEllipse(1, 1, self.radius - 1, self.radius - 1)
painter.drawPixmap(QRect(14, 14, self.radius / 2, self.radius / 2), self.pixmap)
else:
painter.drawEllipse(self.width() / 2, self.height() / 2, self.effect_size, self.effect_size)
painter.end()
def paintEvent(self, event):
cX = self.parent.leftMargin + self.scaleMarkLen
cY = self.parent.topMargin + self.scaleMarkLen
worldX = self.parent.chunkX*16
worldZ = self.parent.chunkZ*16
painter = QPainter()
path = QPainterPath()
painter.begin(self)
painter.save()
#painter.setFont(QFont('Arial Narrow', 8)) #QFont.Bold
# draw scale
x = cX
y = cY
painter.rotate(-90)
for i in range(16):
fr = QRectF(-y, x, self.scaleMarkLen, self.edgeLen)
painter.drawText(fr, Qt.AlignHCenter | Qt.AlignVCenter, '-5555')
painter.drawRect(fr)
#fr = QRectF(-y - 16*self.edgeLen - self.scaleMarkLen, x, self.scaleMarkLen, self.edgeLen)
#painter.drawText(fr, Qt.AlignHCenter | Qt.AlignVCenter, '-5555')
#painter.drawRect(fr)
x += self.edgeLen
painter.rotate(90)
x = self.parent.leftMargin
y = cY
for i in range(16):
fr = QRectF(x, y, self.scaleMarkLen, self.edgeLen)
painter.drawText(fr, Qt.AlignHCenter | Qt.AlignVCenter, '-5555')
painter.drawRect(fr)
#fr = QRectF(x + self.scaleMarkLen + 16*self.edgeLen, y, self.scaleMarkLen, self.edgeLen)
#painter.drawText(fr, Qt.AlignHCenter | Qt.AlignVCenter, '-5555')
#painter.drawRect(fr)
y += self.edgeLen
x = cX
y = cY
for i in range(16):
for j in range(16):
path.addRect(x, y, self.edgeLen, self.edgeLen)
fr = QRectF(x, y, self.edgeLen, self.edgeLen)
#painter.drawText(fr, Qt.AlignHCenter | Qt.AlignVCenter, '-5555')
x += self.edgeLen
x = cX
y += self.edgeLen
painter.drawPath(path)
painter.restore()
painter.end()
del painter
def paintEvent(self, event):
QPushButton.paintEvent(self, event)
qp = QPainter()
qp.begin(self)
font = qp.font()
font.setPixelSize(8)
font.setWeight(QFont.Normal)
qp.setFont(font)
qp.drawText(event.rect().translated(1, 1), str(self._atomic_number))
qp.end()
def paintEvent(self, event):
qp = QPainter()
qp.begin(self)
c = QColor()
c.setNamedColor(self._window_bgcolor)
h, s, l, a = c.getHsl()
c.setHsl(h, s, 100, a)
pen = QPen(c, 8, QtCore.Qt.SolidLine)
qp.setPen(pen)
qp.drawRoundedRect(event.rect(), 12, 12)
qp.end()
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
colour = self._colour
if not self._lit:
colour = self._colour.darker(300)
painter.setPen(QPen(Qt.black, 1))
painter.setBrush(QBrush(colour))
rect = event.rect()
radius = min(rect.width(), rect.height()) / 3
painter.drawEllipse(rect.center(), radius, radius)
painter.end()
def saveAsPDF(self):
'''Save plot as a PDF'''
if not self.control.hasPlot:
error.showMessage('Cannot save.. there is no data to save yet')
return
filter = 'PDF Documents (*.pdf);;All (*)'
d = '' if self.pdfName is None else self.pdfName
s = QFileDialog.getSaveFileName(self, 'PDF File Name',
d, filter)
# Continue unless the user hit cancel
if not s[0]:
return
self.pdfName = s[0]
# Set up the PDF printer
printer = QPrinter()
printer.setOutputFormat(QPrinter.PdfFormat)
printer.setOrientation(QPrinter.Landscape)
printer.setOutputFileName(self.pdfName)
printer.setCreator('RAPID')
# Send to the plot for printing
p = QPainter()
p.begin(printer)
x, y = self.plot.calculatedData()
plt = pgplot(x, y,
antialias=True,
connect='all',
pen={'color': 'b', 'width': 0})
plt.setLabel('bottom', "Frequency (Wavenumbers, cm<sup>-1</sup>)")
plt.getAxis('bottom').setPen('k')
plt.setLabel('left', "Intensity (Normalized)")
plt.getAxis('left').setPen('k')
plt.setYRange(0, 1.1, padding=0)
plt.invertX(self.plot.reversed)
plt.setBackground('w') # White
# The raw (experimental) data, if any
if self.plot.rawData is not None:
data = self.plot.getRawData()
x, y = data[:,0], data[:,1]
curve2 = PlotCurveItem(x, y,
antialias=True,
connect='all',
pen={'color': 'g', 'width': 0})
plt.addItem(curve2)
plt.render(p)
p.end()
def draw_uvs(self):
self.img = QPixmap(QSize(self.w, self.h))
pen = QPen()
pen.setWidth(int(self.pen_w.text()))
pen.setBrush(QBrush(Qt.white))
pen.setColor(QColor('white'))
painter = QPainter()
painter.begin(self.img)
painter.setPen(pen)
coords = self.get_coords()
for face in coords:
for n in xrange(len(face) - 1):
print face[n][0], face[n][1], face[n + 1][0], face[n + 1][1]
painter.drawLine(face[n][0], face[n][1], face[n + 1][0], face[n + 1][1])
painter.end()
self.view.scene().addPixmap(self.img)
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.HighQualityAntialiasing)
painter.setRenderHint(QPainter.Antialiasing)
painter.setRenderHint(QPainter.SmoothPixmapTransform)
painter.setBrush(self.color)
if self.effect_size == self.radius:
painter.drawEllipse(1, 1, self.radius - 1, self.radius - 1)
painter.drawPixmap(QRect(14, 14, self.radius / 2, self.radius / 2),
self.pixmap)
else:
painter.drawEllipse(self.width() / 2,
self.height() / 2, self.effect_size,
self.effect_size)
painter.end()
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
if self._lit:
self._colour.setAlphaF(1)
else:
self._colour.setAlphaF(.25)
painter.setPen(QPen(self._colour, 1))
painter.setBrush(QBrush(self._colour))
rect = event.rect()
radius = min(rect.width(), rect.height()) / 3
painter.drawEllipse(rect.center(), radius, radius)
painter.end()
def generateCursor(self, element):
cursorPixmap = QPixmap(32,32)
hotX = element.getAttribute('__hotX')
if hotX == None:
hotX = element.width()/2
hotY = element.getAttribute('__hotY')
if hotY == None:
hotY = element.height()/2
cursorPixmap.fill(Qt.transparent)
element.moveTo(0,0)
painter = QPainter()
painter.begin(cursorPixmap)
id = element.getAttribute('id')
assert id != None and isinstance(id,str)
self.render(painter,"#" + id)
painter.end()
return QCursor(cursorPixmap,hotX,hotY)
def createPixmap(self):
"""Creates the pixmap shown when this label is dragged."""
font_metric = QFontMetrics(QFont())
text_size = font_metric.size(Qt.TextSingleLine, self.text)
image = QImage(text_size.width() + 4,
text_size.height() + 4,
QImage.Format_ARGB32_Premultiplied)
image.fill(qRgba(240, 240, 120, 255))
painter = QPainter()
painter.begin(image)
painter.setFont(QFont())
painter.setBrush(Qt.black)
painter.drawText(QRect(QPoint(2, 2), text_size), Qt.AlignCenter,
self.text)
painter.end()
return image
def paintEvent(self, event):
width = event.rect().width() - 1
scale = float(width) / self._sizeValue.width()
self._fontCurrent.setPointSizeF(scale * self.WEIGHT_CURRENT * 10)
self._fontValue.setPointSizeF(scale * self.WEIGHT_VALUE * 10)
self._fontRange.setPointSizeF(scale * self.WEIGHT_RANGE * 10)
painter = QPainter()
painter.begin(self)
painter.setPen(QPen(QColor(42, 67, 107), 4 * scale))
pos = self.__drawText(painter, scale)
pos = self.__drawBar(painter, scale, width, pos)
painter.end()
self.setMinimumHeight(pos)
def testFromData(self):
picture = QPicture()
painter = QPainter()
painter.begin(picture)
painter.drawEllipse(10, 20, 80, 70)
painter.end()
data = picture.data()
picture2 = QPicture()
picture2.setData(data)
self.assertEqual(picture2.data(), picture.data())
w = MyWidget()
w._picture = picture2
w._app = self.app
QTimer.singleShot(300, w.show)
self.app.exec_()
def paintEvent(self, event):
"""
This function handles the low level painting of component.
:param event:
:return:
"""
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
if self.__flag == 1:
painter.end()
return
# setting the masking ellipse
painter.setClipRegion(self.__clip)
self.__color.setAlpha(self.__maxOpacity)
painter.setBrush(QBrush(self.__color))
painter.setPen(QPen(QColor(0, 0, 0, 0)))
painter.drawEllipse(self.__origin, self.__r, self.__r)
painter.end()
def paintEvent(self, event):
'''
Method to run on paint events
'''
painter = QPainter()
# Get a QPainter object
painter.begin(self)
# Begin painting
painter.setRenderHint(QPainter.Antialiasing)
# Set a rendering option
painter.setBrush(Qt.transparent)
# Set the paint brush to transparent
painter.drawRect(0, 0, 20, 20)
# Draw a rectangle with width = height = 20
painter.setBrush(Qt.green)
# Set the paint brush color to green
painter.drawEllipse(QPoint(10, 10), 9, 9)
# Draw a circle that fills most of the rectangle
painter.end()
def testFromData(self):
picture = QPicture()
painter = QPainter()
painter.begin(picture)
painter.drawEllipse(10, 20, 80, 70)
painter.end()
data = picture.data()
picture2 = QPicture()
picture2.setData(data)
self.assertEqual(picture2.data(), picture.data())
w = MyWidget()
w._picture = picture2
w._app = self.app
QTimer.singleShot(300, w.show)
self.app.exec_()
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.HighQualityAntialiasing)
painter.setRenderHint(QPainter.SmoothPixmapTransform)
painter.setBrush(QColor(255, 255, 255))
painter.drawRect(QRect(0, -1, self.window().width(), 76))
if self.icon:
painter.drawPixmap(QRect(16, 16, 32, 32), self.icon)
if self.title:
painter.setFont(QFont("Roboto\\Roboto-Regular.ttf", 20))
if qt_ver() != "PySide":
painter.drawText(QRect(56, 0, 64, 48),0, self.title)
else:
painter.drawText(QRect(56, 0, 64, 48), self.title)
if self.text:
painter.setFont(QFont("Roboto\\Roboto-Regular.ttf", 13))
if qt_ver() != "PySide":
painter.drawText(QRect(56, self.height() / 2, self.window().width() - 56, 36),0, self.text)
painter.end()
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.HighQualityAntialiasing)
painter.setRenderHint(QPainter.Antialiasing)
painter.setRenderHint(QPainter.SmoothPixmapTransform)
self.img = QPixmap()
if self.isChecked():
painter.setBrush(self.color1)
painter.drawRoundedRect(QRect(-1, -1, 31, 31), 7, 7)
painter.drawPixmap(QRect(-2, -5, 35, 40), self.img.fromImage(self.check))
else:
pen = QPen()
pen.setWidth(2)
painter.setPen(pen)
# hand draw rect
painter.drawLine(QPoint(0, 0), QPoint(30, 0))
painter.drawLine(QPoint(30, 0), QPoint(30, 30))
painter.drawLine(QPoint(0, 0), QPoint(0, 30))
painter.drawLine(QPoint(0, 30), QPoint(30, 30))
painter.end()
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.HighQualityAntialiasing)
painter.setRenderHint(QPainter.Antialiasing)
painter.setRenderHint(QPainter.SmoothPixmapTransform)
self.img = QPixmap()
if self.isChecked():
painter.setBrush(self.color1)
painter.drawRoundedRect(QRect(-1, -1, 31, 31), 7, 7)
painter.drawPixmap(QRect(-2, -5, 35, 40),
self.img.fromImage(self.check))
else:
pen = QPen()
pen.setWidth(2)
painter.setPen(pen)
# hand draw rect
painter.drawLine(QPoint(0, 0), QPoint(30, 0))
painter.drawLine(QPoint(30, 0), QPoint(30, 30))
painter.drawLine(QPoint(0, 0), QPoint(0, 30))
painter.drawLine(QPoint(0, 30), QPoint(30, 30))
painter.end()
def paintEvent(self, event):
"""Display a translucent rounded rectangle."""
roundness = 10
rect = self.rect()
bgcolor = self.palette().color(QPalette.Background)
alpha_bgcolor = QColor(50, 50, 50, 150)
# alpha_bgcolor = QColor(bgcolor.red(), bgcolor.green(),
# bgcolor.blue(), 150)
painter = QPainter()
painter.begin(self)
painter.save()
painter.setRenderHint(QPainter.Antialiasing)
painter.setPen(Qt.red)
rounded_rect = QPainterPath()
rounded_rect.addRoundRect(1, 1, rect.width() - 2, rect.height() - 2, roundness, roundness)
painter.setClipPath(rounded_rect)
self.setMask(painter.clipRegion())
painter.setOpacity(1.0)
painter.fillPath(rounded_rect, QBrush(alpha_bgcolor))
painter.restore()
painter.end()
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.HighQualityAntialiasing)
painter.setRenderHint(QPainter.SmoothPixmapTransform)
painter.setBrush(QColor(255, 255, 255))
painter.drawRect(QRect(0, -1, self.window().width(), 76))
if self.icon:
painter.drawPixmap(QRect(16, 16, 32, 32), self.icon)
if self.title:
painter.setFont(QFont("Roboto\\Roboto-Regular.ttf", 20))
if qt_ver() != "PySide":
painter.drawText(QRect(56, 0, 64, 48), 0, self.title)
else:
painter.drawText(QRect(56, 0, 64, 48), self.title)
if self.text:
painter.setFont(QFont("Roboto\\Roboto-Regular.ttf", 13))
if qt_ver() != "PySide":
painter.drawText(
QRect(56,
self.height() / 2,
self.window().width() - 56, 36), 0, self.text)
painter.end()
def paintEvent(self, event):
"""Display a translucent rounded rectangle."""
roundness = 10
rect = self.rect()
bgcolor = self.palette().color(QPalette.Background)
alpha_bgcolor = QColor(50, 50, 50, 150)
#alpha_bgcolor = QColor(bgcolor.red(), bgcolor.green(),
# bgcolor.blue(), 150)
painter = QPainter()
painter.begin(self)
painter.save()
painter.setRenderHint(QPainter.Antialiasing)
painter.setPen(Qt.red)
rounded_rect = QPainterPath()
rounded_rect.addRoundRect(1, 1,
rect.width() - 2,
rect.height() - 2, roundness, roundness)
painter.setClipPath(rounded_rect)
self.setMask(painter.clipRegion())
painter.setOpacity(1.0)
painter.fillPath(rounded_rect, QBrush(alpha_bgcolor))
painter.restore()
painter.end()
def paintEvent(self, e):
qp = QPainter()
qp.begin(self)
qp.setBrush(self.value)
qp.drawRect(0, 5, self.width, self.height)
qp.end()
def paintEvent(self, e):
qp = QPainter()
qp.begin(self)
qp.setBrush(QColor(*self.value))
qp.drawRect(0, 0, self.bar_width, 20)
qp.end()
def paintEvent(self, e):
qp = QPainter()
qp.begin(self)
qp.setBrush(QColor(*self.value))
qp.drawRect(0, 0, self.bar_width, 20)
qp.end()
def paintEvent(self, e):
qp = QPainter()
qp.begin(self)
qp.setBrush(self.value)
qp.drawRect(0, 5, self.width, self.height)
qp.end()
def paintEvent(self, event):
p = QPainter()
p.begin(self)
p.fillRect(self.rect(), QBrush(QColor(240, 200, 0)))
p.end()
def paintEvent(self, event):
qp = QPainter()
qp.begin(self)
self.drawLines(qp)
qp.end()
class GrWidget(QWidget):
def __init__(self):
super(GrWidget, self).__init__()
self.setup_ui(self)
os.environ["GKS_WSTYPE"] = "381"
os.environ["GKS_DOUBLE_BUF"] = "True"
self.w = 500
self.h = 500
self.beginx = self.x = 0
self.beginy = self.y = 0
self.painter = QPainter()
self.isolevel = (data.min() + data.max()) // 2
self.export = False
self.needs_refresh = True
@staticmethod
def setup_ui(form):
form.setWindowTitle("GrWidget")
form.resize(QtCore.QSize(500, 500).expandedTo(form.minimumSizeHint()))
def draw_image(self):
if not self.needs_refresh:
return
self.needs_refresh = False
gr.clearws()
gr.setwindow(0, self.w, 0, self.h)
gr.setviewport(0, 1, 0, 1)
gr3.setbackgroundcolor(1, 1, 1, 0)
vertices, normals = gr3.triangulate(data,
(1.0 / 64, 1.0 / 64, 1.0 / 128),
(-0.5, -0.5, -0.5), self.isolevel)
mesh = gr3.createmesh(
len(vertices) * 3, vertices, normals, np.ones(vertices.shape))
gr3.drawmesh(mesh, 1, (0, 0, 0), (0, 0, 1), (0, 1, 0), (1, 1, 1),
(1, 1, 1))
center = spherical_to_cartesian(-2,
np.pi * self.y / self.h + np.pi / 2,
np.pi * self.x / self.w)
up = spherical_to_cartesian(1, np.pi * self.y / self.h + np.pi,
np.pi * self.x / self.w)
gr3.cameralookat(center[0], center[1], -0.25 + center[2], 0, 0, -0.25,
up[0], up[1], up[2])
gr3.drawimage(0, self.w, 0, self.h, self.w, self.h,
gr3.GR3_Drawable.GR3_DRAWABLE_GKS)
if self.export:
gr3.export("mri.html", 800, 800)
print("Saved current isosurface to mri.html")
self.export = False
gr3.clear()
gr3.deletemesh(c_int(mesh.value))
def mouseMoveEvent(self, event):
self.x += event.pos().x() - self.beginx
self.y -= event.pos().y() - self.beginy
self.beginx = event.pos().x()
self.beginy = event.pos().y()
self.needs_refresh = True
self.update()
def mousePressEvent(self, event):
self.beginx = event.pos().x()
self.beginy = event.pos().y()
def keyPressEvent(self, event):
if event.key() == QtCore.Qt.Key_Escape:
self.close()
elif event.text() == 'h':
self.export = True
self.needs_refresh = True
self.update()
def wheelEvent(self, ev):
if hasattr(ev, 'delta'):
delta = ev.delta()
else:
delta = ev.angleDelta().y()
if delta > 0:
if self.isolevel * 1.01 < data.max():
self.isolevel *= 1.01
else:
if self.isolevel * 0.99 > data.min():
self.isolevel *= 0.99
self.isolevel = int(self.isolevel + 0.5)
self.needs_refresh = True
self.update()
def resizeEvent(self, event):
self.needs_refresh = True
self.update()
def paintEvent(self, ev):
self.painter.begin(self)
if have_pyside:
os.environ['GKSconid'] = "%x!%x" % (
int(shiboken.getCppPointer(self)[0]),
int(shiboken.getCppPointer(self.painter)[0]))
else:
os.environ["GKSconid"] = "%x!%x" % (unwrapinstance(self),
unwrapinstance(self.painter))
self.draw_image()
gr.updatews()
self.painter.end()
def paintEvent(self, event):
cX = self.parent.lytLeftMargin + self.scaleMarkLen
cY = self.parent.lytTopMargin + self.scaleMarkLen
worldX = self.parent.presenter.showChunkX*16
worldZ = self.parent.presenter.showChunkZ*16
painter = QPainter()
path = QPainterPath()
painter.begin(self)
painter.save()
#painter.setFont(QFont('Arial Narrow', 8)) #QFont.Bold
# draw scale
x = cX
y = cY
painter.rotate(-90)
for i in range(16):
fr = QRectF(-y, x, self.scaleMarkLen, self.edgeLen)
painter.drawText(fr, Qt.AlignHCenter | Qt.AlignVCenter, str(worldX))
#painter.drawRect(fr)
#fr = QRectF(-y - 16*self.edgeLen - self.scaleMarkLen, x, self.scaleMarkLen, self.edgeLen)
#painter.drawText(fr, Qt.AlignHCenter | Qt.AlignVCenter, '-5555')
#painter.drawRect(fr)
x += self.edgeLen
worldX += 1
painter.rotate(90)
x = self.parent.lytLeftMargin
y = cY
for i in range(16):
fr = QRectF(x, y, self.scaleMarkLen, self.edgeLen)
painter.drawText(fr, Qt.AlignHCenter | Qt.AlignVCenter, str(worldZ))
#painter.drawRect(fr)
#fr = QRectF(x + self.scaleMarkLen + 16*self.edgeLen, y, self.scaleMarkLen, self.edgeLen)
#painter.drawText(fr, Qt.AlignHCenter | Qt.AlignVCenter, '-5555')
#painter.drawRect(fr)
y += self.edgeLen
worldZ += 1
x = cX
y = cY
for i in range(16):
for j in range(16):
path.addRect(x, y, self.edgeLen, self.edgeLen)
#fr = QRectF(x, y, self.edgeLen, self.edgeLen)
#painter.drawText(fr, Qt.AlignHCenter | Qt.AlignVCenter, '-5555')
x += self.edgeLen
x = cX
y += self.edgeLen
painter.drawPath(path)
slice_ = self.parent.presenter.getSlice(self.parent.presenter.elevation)
x = cX
y = cY
bru = QBrush()
#path1 = QPainterPath()
for i in range(16):
for j in range(16):
if slice_[i][j] in self.parent.selectedMinerals.list_:
lePen = painter.pen()
newPen = QPen(bru, 3)
newPen.setColor(self.parent.selectedMinerals.getColor(slice_[i][j]))
painter.setPen(newPen)
painter.drawRect(x, y, self.edgeLen, self.edgeLen)
painter.setPen(lePen)
x += self.edgeLen
x = cX
y += self.edgeLen
painter.restore()
painter.end()
del painter
def paintEvent(self, event):
p = QPainter()
p.begin(self)
p.fillRect(self.rect(), QBrush(QColor(240, 200, 0)))
p.end()
def paintEvent(self, event):
qp = QPainter()
qp.begin(self)
self._draw_slices(event, qp)
self._draw_indicator(event, qp)
qp.end()
def paintEvent(self, event):
qp = QPainter()
qp.begin(self)
self.drawing(qp)
def add_labels_internal(self, gl, render_state, draw_to_canvas, labels):
'''
call to add a list of labels
'''
text_paint = QPainter()
if draw_to_canvas:
text_paint.begin(self.bitmap)
text_paint.setRenderHints(QPainter.Antialiasing)
u = 0
v = 0
line_height = 0
for label in labels:
ascent = 0
descent = 0
measured_text_width = 0
height = 0
width = 0
font_size = label.font_size
while True:
metrics = None
if draw_to_canvas:
mask = 0x000000FF
b = (label.color >> 16) & mask
g = (label.color >> 8) & mask
r = label.color & mask
######################################################################## LINE CHANGED
text_paint.setPen(QColor(0, 0, 0))
#text_paint.setPen(QColor(r, g, b))
# The value 0.75 is hard coded representing phone pixel density
text_paint.setFont(QFont('Veranda', font_size * 0.75))
# Paint.ascent is negative, so negate it.
metrics = text_paint.fontMetrics()
else:
# The value 0.75 is hard coded representing phone pixel density
metrics = QFontMetrics(QFont('Veranda', font_size * 0.75))
ascent = math.ceil(metrics.ascent())
descent = math.ceil(metrics.descent())
measured_text_width = math.ceil(metrics.boundingRect(label.string).width())
height = int(ascent) + int(descent)
width = int(measured_text_width)
# If it's wider than the screen, try it again with a font size of 1
# smaller.
font_size -= 1
if font_size < 0 or width < render_state.screen_width:
break
next_u = 0
# Is there room for this string on the current line?
if u + width > self.strike_width:
# No room, go to the next line:
u = 0
next_u = width
v += line_height
line_height = 0
else:
next_u = u + width
line_height = max(line_height, height)
if (v + line_height > self.strike_height) and draw_to_canvas:
raise Exception("out of texture space.")
v_base = v + ascent
if draw_to_canvas:
text_paint.drawText(int(u), int(v_base), label.string)
label.set_texture_data(width, height, u, v + height, width, -height,
self.texel_width, self.texel_height)
u = next_u
if draw_to_canvas:
text_paint.end()
return v + line_height
def paintEvent(self, event):
qp = QPainter()
qp.begin(self)
qp.setRenderHint(QPainter.Antialiasing)
qp.setBrush(self.color)
qp.setPen(self.color)
rect = event.rect()
x = rect.x()
w = rect.width()
lineheight = 16
print '-------------------'
print 'lefts', self.lefts
print 'rights', self.rights
print '-------------------'
ly = self._left_y + 5
ry = self._right_y + 5
rs = self.rights[:]
# offset=1
for i, l in enumerate(self.lefts):
path = QPainterPath()
sl, el = l[0], l[-1]
try:
r = rs[i]
sr, er = r[0], r[-1]
rs.pop(i)
# offset+=1
except IndexError:
sr, er = l[-1], l[-1] - 1
y = ly + lineheight * sl
y2 = ry + lineheight * sr
path.moveTo(x, y)
path.lineTo(x, y + lineheight * (el - sl + 1))
path.lineTo(x + w, y2 + lineheight * (er - sr + 1))
path.lineTo(x + w, y2)
qp.drawPath(path)
for i, r in enumerate(rs):
path = QPainterPath()
sr, er = r[0], r[-1]
# try:
l = self.lefts[i]
sl, el = r[-1], r[-1] - 1
# except IndexError:
# sl, el = l[-1]+2, l[-1]+1
# print sl, el
y = ly + lineheight * (sl)
y2 = ry + lineheight * (sr)
path.moveTo(x, y)
path.lineTo(x, y + lineheight * (el - sl + 1))
path.lineTo(x + w, y2 + lineheight * (er - sr + 1))
path.lineTo(x + w, y2)
qp.drawPath(path)
qp.end()
