def paintEvent(self, e):
qp = QPainter()
qp.begin(self)
self.drawWidget(qp)
qp.end()
super().paintEvent(e)
def paintEvent(self, evt):
"""
Protected method handling a paint event.
@param evt reference to the paint event (QPaintEvent)
"""
super(E5LineEdit, self).paintEvent(evt)
if qVersion() < "4.7.0":
if not self.text() and \
self.__inactiveText and \
not self.hasFocus():
panel = QStyleOptionFrame()
self.initStyleOption(panel)
textRect = self.style().subElementRect(
QStyle.SE_LineEditContents, panel, self)
textRect.adjust(2, 0, 0, 0)
left = self.textMargin(self.LeftSide)
right = self.textMargin(self.RightSide)
textRect.adjust(left, 0, -right, 0)
painter = QPainter(self)
painter.setPen(self.palette().brush(
QPalette.Disabled, QPalette.Text).color())
painter.drawText(
textRect, Qt.AlignLeft | Qt.AlignVCenter,
self.__inactiveText)
def set_debugging_status(self, status):
if status == 0:
text = "Idle ..."
color = "gray"
elif status == 1:
text = 'Waiting for connection ...'
color = "orange"
elif status == 2:
text = 'Debugging stopped ...'
color = "red"
elif status == 3:
text = 'Debugging in progress ...'
color = "green"
elif status == 4:
text = 'Running ...'
color = "blue"
self.label.setText(text)
self.pixmap = QPixmap(10, 10)
color = QColor(color)
self.pixmap.fill(color)
painter = QPainter(self.pixmap)
painter.drawRect(0, 0, 10, 10)
self.light.setPixmap(self.pixmap)
def paintEvent(self, event):
QWidget.paintEvent(self, event)
self.update_cache()
if not self.cache:
return
rect = self._nscrollbar.overlay_rect()
sb_range = self._nscrollbar.get_scrollbar_range()
sb_range = max(self.visible_range, sb_range)
# horizontal_margin = 3
# result_width = rect.width() - 2 * horizontal_margin + 1
result_width = rect.width() / 3
result_height = min(rect.height() / sb_range + 1, 4)
# x = rect.left() + horizontal_margin
x = rect.center().x() - 1
offset = rect.height() / sb_range * self.range_offset
vertical_margin = ((rect.height() / sb_range) - result_height) / 2
painter = QPainter(self)
for lineno in self.cache.keys():
marker = self.cache[lineno]
top = rect.top() + offset + vertical_margin + \
marker.position / sb_range * rect.height()
# bottom = top + result_height
painter.fillRect(
x,
top,
result_width,
4,
QColor(marker.color))
def draw(self, painter: QPainter):
pen = QPen(Layer.color(LayerType.annotate))
pen.setCapStyle(Qt.RoundCap)
pen.setJoinStyle(Qt.RoundJoin)
pen.setWidth(0)
painter.setPen(pen)
painter.drawLine(self.pt1, self.pt2)
def print_(self):
"""Prints the document."""
self._stop = False
resolution = self.resolution()
p = self.printer()
p.setFullPage(True)
p.setResolution(resolution)
center = p.paperRect().center()
painter = QPainter(p)
pages = self.pageList()
if p.pageOrder() != QPrinter.FirstPageFirst:
pages.reverse()
total = len(pages)
opts = self.renderOptions()
document = self.document()
for num, pageNum in enumerate(pages, 1):
if self._stop:
return p.abort()
self.progress(num, total, pageNum)
if num > 1:
p.newPage()
with lock(document):
opts.write(document)
page = document.page(pageNum - 1)
img = page.renderToImage(resolution, resolution)
rect = img.rect()
rect.moveCenter(center)
painter.drawImage(rect, img)
return painter.end()
def paintEvent(self, event):
"""QToolBar.paintEvent reimplementation
Draws buttons, dock icon and text
"""
rect = self._spacer.rect()
painter = QPainter(self)
transform = QTransform()
transform.translate(self._spacer.pos().x(), self._spacer.pos().y())
painter.setTransform(transform)
""" Not supported currently
if self._dock.features() & QDockWidget.DockWidgetVerticalTitleBar :
transform = QTransform()
rect.setSize(QSize(rect.height(), rect.width()))
transform.rotate(-90)
transform.translate(-rect.width(), 0)
painter.setTransform(transform)
"""
# icon / title
optionB = QStyleOptionButton()
optionB.initFrom(self._dock)
optionB.rect = rect
optionB.text = self._dock.windowTitle()
optionB.iconSize = self.iconSize()
optionB.icon = self._dock.windowIcon()
self.style().drawControl(QStyle.CE_PushButtonLabel, optionB, painter, self._dock)
def paintEvent(self, event):
super(TetrixBoard, self).paintEvent(event)
painter = QPainter(self)
rect = self.contentsRect()
if self.isPaused:
painter.drawText(rect, Qt.AlignCenter, "Pause")
return
boardTop = rect.bottom() - TetrixBoard.BoardHeight * self.squareHeight()
for i in range(TetrixBoard.BoardHeight):
for j in range(TetrixBoard.BoardWidth):
shape = self.shapeAt(j, TetrixBoard.BoardHeight - i - 1)
if shape != NoShape:
self.drawSquare(painter,
rect.left() + j * self.squareWidth(),
boardTop + i * self.squareHeight(), shape)
if self.curPiece.shape() != NoShape:
for i in range(4):
x = self.curX + self.curPiece.x(i)
y = self.curY - self.curPiece.y(i)
self.drawSquare(painter, rect.left() + x * self.squareWidth(),
boardTop + (TetrixBoard.BoardHeight - y - 1) * self.squareHeight(),
self.curPiece.shape())
def paintEvent(self, e):
print("Paint event")
qp = QPainter()
qp.begin(self)
self.drawRectangles(qp)
qp.end()
def paintEvent(self, e):
painter = QPainter(self)
w = self.width()
h = self.height()
painter.fillRect(0, 0, w, h, QBrush(QColor(255, 255, 255)))
self.drawCoordLines(painter, w, h)
self.drawModel(painter, w, h)
def lineNumberAreaPaintEvent(self, event): # When text zoomed line number not zoomed
"""Painting line number area"""
painter = QPainter(self.lineNumberArea)
painter.fillRect(event.rect(), Qt.lightGray)
block = self.firstVisibleBlock()
blockNumber = block.blockNumber()
top = int(self.blockBoundingGeometry(block).translated(self.contentOffset()).top())
bottom = top + int(self.blockBoundingRect(block).height())
# font_height = self.fontMetrics().height()
while block.isValid() and top <= event.rect().bottom():
if block.isVisible() and bottom >= event.rect().top():
font_original = self.document().defaultFont()
size = font_original.pointSize()
font = painter.font()
font.setPointSize(size)
painter.setFont(font)
number = str(blockNumber + 1)
painter.setPen(Qt.black)
painter.drawText(0, top, self.lineNumberArea.width(),
self.fontMetrics().height(),
Qt.AlignRight, number)
block = block.next()
top = bottom
bottom = top + int(self.blockBoundingRect(block).height())
blockNumber += 1
def paintEvent(self, event):
painter = QPainter(self.viewport())
painter.drawTiledPixmap(0, 0, self.fPixmapWidth, self.height(), self.fPixmapL)
painter.drawTiledPixmap(
self.width() - self.fPixmapWidth - 2, 0, self.fPixmapWidth, self.height(), self.fPixmapR
)
QListWidget.paintEvent(self, event)
def drawData(self, points=[], color=Qt.black):
painter = QPainter(self.image)
painter.setPen(QPen(color, self.myPenWidth, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin))
for n in range(len(points) - 1):
painter.drawLine(points[n][0], points[n][1], points[n + 1][0], points[n + 1][1])
self.update()
class ModCrossButton(QPushButton):
def __init__(self,parent,path=None):
QPushButton.__init__(self,parent)
self.parent=parent
#self.setAttribute(Qt.WA_TranslucentBackground, True)
self.backgroundColor = QPalette().light().color()
self.backgroundColor.setRgb(157,157,157) #(220,203,231)
#self.backgroundColor.setAlpha(100)
self.brush=QBrush(Qt.SolidPattern)
def paintEvent(self,event):
self.wide=self.width()
self.high=self.height()
self.xdis=self.wide/7
self.ydis=self.xdis
self.path=QPainterPath()
self.path.setFillRule(Qt.OddEvenFill)
self.path.moveTo(self.wide/2, self.high/2-self.xdis)
self.path.arcTo(0,0, self.wide, self.high,0,360)
#self.path.closeSubpath()
self.path.moveTo(self.wide/2-self.xdis/2, self.ydis)
self.path.lineTo(self.wide/2-self.xdis/2, self.high/2-self.xdis/2)
self.path.lineTo(self.ydis, self.high/2-self.xdis/2)
self.path.lineTo(self.ydis, self.high/2+self.xdis/2)
self.path.lineTo(self.wide/2-self.xdis/2, self.high/2+self.xdis/2)
self.path.lineTo(self.wide/2-self.xdis/2, self.high-self.ydis)
self.path.lineTo(self.wide/2+self.xdis/2, self.high-self.ydis)
self.path.lineTo(self.wide/2+self.xdis/2, self.high/2+self.xdis/2)
self.path.lineTo(self.wide-self.ydis, self.high/2+self.xdis/2)
self.path.lineTo(self.wide-self.ydis, self.high/2-self.xdis/2)
self.path.lineTo(self.wide/2+self.xdis/2, self.high/2-self.xdis/2)
self.path.lineTo(self.wide/2+self.xdis/2, self.ydis)
self.path.closeSubpath()
self.brush.setColor(self.backgroundColor)
self.painter=QPainter(self)
self.painter.setRenderHint(QPainter.Antialiasing)
self.painter.setPen(Qt.NoPen)
self.painter.setBrush(self.brush)
self.painter.drawPath(self.path)
self.painter.end()
#def mousePressEvent(self,ev):
# self.parent.close()
def enterEvent(self,ev):
self.backgroundColor.setRgb(242,146,52)
self.update()
def leaveEvent(self,ev):
self.backgroundColor.setRgb(157,157,157)
self.update()
def paintEvent(self, event):
"""QLineEdit.paintEvent implementation.
Draws prompt
"""
QLineEdit.paintEvent(self, event)
if self._promptText and not self.text() and self.isEnabled():
option = QStyleOptionFrameV3()
self.initStyleOption(option)
left, top, right, bottom = self.getTextMargins()
va = self.style().visualAlignment(self.layoutDirection(), self.alignment())
rect = (
self.style()
.subElementRect(QStyle.SE_LineEditContents, option, self)
.adjusted(2, 0, 0, 0)
.adjusted(left, top, -right, -bottom)
)
fm = QFontMetrics(self.font())
text = fm.elidedText(self._promptText, Qt.ElideRight, rect.width())
painter = QPainter(self)
painter.setPen(self.palette().color(QPalette.Disabled, QPalette.Text))
painter.drawText(rect, va, text)
def paintEvent(self,ev):
self.brush.setColor(self.linecolor)
self.painter=QPainter(self)
self.painter.setRenderHint(QPainter.Antialiasing)
self.painter.setPen(Qt.NoPen)
self.painter.setBrush(self.brush)
self.painter.drawRect(0, 0, self.width(), self.lx)
self.painter.end()
#print(1)
self.painter2=QPainter(self)
self.painter2.setRenderHint(QPainter.Antialiasing)
self.painter2.setPen(Qt.NoPen)
self.painter2.setBrush(self.brush2)
self.brush2.setColor(self.backgroundColor)
self.painter2.drawRect(0,self.lx,self.width(),self.height()-self.lx)
self.painter2.end()
#print(2)
self.painter3=QPainter(self)
self.painter3.drawText(1,self.lx,self.width()-2,self.height()-self.lx,Qt.AlignCenter,self.text)
self.painter3.end()
class RoundedPushButton1(QPushButton):
def __init__(self,parent, default_wide, default_high,text=''):
QPushButton.__init__(self, parent)
#self.resize(100,80)
self.default_high=default_high
self.default_wide=default_wide
self.xrd=self.default_wide/10
#self.yrd=self.default_high/10
self.yrd=self.xrd
#self.resize(self.default_wide,self.default_high)
self.backgroundColor = QPalette().light().color()
self.backgroundColor.setRgb(157,157,157) #(220,203,231)
#self.backgroundColor.setAlpha(0)
self.brush=QBrush(Qt.SolidPattern)
self.textlabel=textQLabel(self,text)
def paintEvent(self,event):
#brush.setStyle(Qt.Dense1Pattern)
self.brush.setColor(self.backgroundColor)
self.painter=QPainter(self)
self.painter.setRenderHint(QPainter.Antialiasing)
self.painter.setPen(Qt.NoPen)
self.painter.setBrush(self.brush)
self.painter.drawRoundedRect(QRect(0,0,self.default_wide,self.default_high), self.xrd, self.yrd)
#self.painter.drawPixmap(self.imgx, self.imgy, self.piximg)
self.painter.end()
def paintEvent(self, ev):
if self.min is not None and self.max is not None:
opt = QStyleOptionSlider()
self.initStyleOption(opt)
opt.subControls = QStyle.SC_SliderGroove | QStyle.SC_SliderHandle
if self.tickPosition() != self.NoTicks:
opt.subControls |= QStyle.SC_SliderTickmarks
groove_rect = self.style().subControlRect(
QStyle.CC_Slider,
opt,
QStyle.SC_SliderGroove,
self
)
rect = QRect(
groove_rect.left() + self.min * groove_rect.width(),
groove_rect.top(),
(self.max-self.min) * groove_rect.width(),
groove_rect.height()
)
painter = QPainter(self)
painter.fillRect(rect, QBrush(Qt.red))
super(ColorRangeSlider, self).paintEvent(ev)
def paintEvent(self, event):
if not hasattr(self, "_currentImage"):
return super(Lolita, self).paintEvent(event)
if isinstance(self._currentImage, QMovie): # 动画
return super(Lolita, self).paintEvent(event)
painter = QPainter(self)
painter.drawPixmap(0, 0, self._currentImage)
def paintEvent(self, event):
painter = QPainter(self)
event.accept()
self._loadPixmapNow()
painter.drawPixmap(self.fPixmapRect, self.fPixmap, self.fPixmapRect)
def __print(self, printer):
"""
Private slot to the actual printing.
@param printer reference to the printer object (QPrinter)
"""
p = QPainter(printer)
marginX = (printer.pageRect().x() - printer.paperRect().x()) // 2
marginY = (printer.pageRect().y() - printer.paperRect().y()) // 2
# double the margin on bottom of page
if printer.orientation() == QPrinter.Portrait:
width = printer.width() - marginX * 2
height = printer.height() - marginY * 3
else:
marginX *= 2
width = printer.width() - marginX * 2
height = printer.height() - marginY * 2
if qVersion() >= "5.0.0":
img = self.mainWidget.grab().toImage()
else:
img = QPixmap.grabWidget(self.mainWidget).toImage()
self.__updateChildren(self.lastStyle)
p.drawImage(marginX, marginY,
img.scaled(width, height,
Qt.KeepAspectRatio, Qt.SmoothTransformation))
p.end()
def paintEvent(self, e):
_width = self.width()
_height = self.height()
painter=QPainter(self)
pen = QPen(Qt.black, 2)
painter.setPen(pen)
#Widget center
painter.translate(QPoint(_width/2, _height/2))
# Draw laser
colorLaser = Qt.blue
colorTLaser = Qt.red
yaw = self.winParent.getPose3D().yaw
#painter.rotate(-180*yaw/pi)
self.drawLaser(painter, colorLaser, self.laser)
if self.tLaser != []:
self.drawLaser(painter, colorTLaser, self.tLaser)
# Draw axis
#painter.rotate(180*yaw/pi)
self.drawAxis(painter)
# Draw Robot (triangle)
#painter.rotate(-180*yaw/pi)
self.drawRobot(painter)
def getCombinedIcon(keys, cache=pixCache):
"""
Module function to retrieve a symbolic link icon.
@param keys list of names of icons (string)
@param cache reference to the pixmap cache object (PixmapCache)
@return the requested icon (QIcon)
"""
height = width = 0
pixmaps = []
for key in keys:
pix = cache.getPixmap(key)
if not pix.isNull():
height = max(height, pix.height())
width = max(width, pix.width())
pixmaps.append(pix)
if pixmaps:
pix = QPixmap(len(pixmaps) * width, height)
pix.fill(Qt.transparent)
painter = QPainter(pix)
x = 0
for pixmap in pixmaps:
painter.drawPixmap(x, 0, pixmap.scaled(QSize(width, height)))
x += width
painter.end()
icon = QIcon(pix)
else:
icon = QIcon()
return icon
def paintEvent(self, event):
pix = self.pixmap_hover if self.underMouse() else self.pixmap
if self.isDown():
pix = self.pixmap_pressed
painter = QPainter(self)
painter.drawPixmap(event.rect(), pix)
def render(self):
painter = QPainter(self.printer)
for page in self.layoutPages[:-1]:
page.render(painter)
self.printer.newPage()
self.layoutPages[-1].render(painter)
painter.end()
def paintEvent(self, event):
option=QStyleOption()
option.initFrom(self)
h=option.rect.height()
w=option.rect.width()
if self.m_shape in (QLed.Triangle, QLed.Round):
aspect=(4/3.0) if self.m_shape==QLed.Triangle else 2.0
ah=w/aspect
aw=w
if ah>h:
ah=h
aw=h*aspect
x=abs(aw-w)/2.0
y=abs(ah-h)/2.0
bounds=QRectF(x,y,aw,ah)
else:
size=min(w,h)
x=abs(size-w)/2.0
y=abs(size-h)/2.0
bounds=QRectF(x,y,size,size)
painter=QPainter(self);
painter.setRenderHint(QPainter.Antialiasing, True);
(dark_r,dark_g,dark_b)=self.colours[self.m_onColour if self.m_value else self.m_offColour]
dark_str="rgb(%d,%d,%d)" % (dark_r,dark_g,dark_b)
light_str="rgb(%d,%d,%d)" % self.adjust(dark_r,dark_g,dark_b)
shape = self.shapes[self.m_shape] % (dark_str, light_str)
shape = shape.encode('utf-8')
self.renderer.load(QByteArray(shape))
self.renderer.render(painter, bounds)
def drawBackgroundToPixmap(self):
r = self.sceneRect()
self.background = QPixmap(qRound(r.width()), qRound(r.height()))
self.background.fill(Qt.black)
painter = QPainter(self.background)
bg = QImage("%simg/BG.png" % (colors.SYSPATH))
painter.drawImage(0, 0, bg)
def createImage(self, transform):
if self.type == DemoTextItem.DYNAMIC_TEXT:
return None
sx = min(transform.m11(), transform.m22())
sy = max(transform.m22(), sx)
textItem = QGraphicsTextItem()
textItem.setHtml(self.text)
textItem.setTextWidth(self.textWidth)
textItem.setFont(self.font)
textItem.setDefaultTextColor(self.textColor)
textItem.document().setDocumentMargin(2)
w = textItem.boundingRect().width()
h = textItem.boundingRect().height()
image = QImage(int(w * sx), int(h * sy),
QImage.Format_ARGB32_Premultiplied)
image.fill(QColor(0, 0, 0, 0).rgba())
painter = QPainter(image)
painter.scale(sx, sy)
style = QStyleOptionGraphicsItem()
textItem.paint(painter, style, None)
return image
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
getWorld().draw(painter)
painter.end()
def createEditor(self, parent: QWidget, option: QStyleOptionViewItem, index: QModelIndex):
editor = QComboBox(parent)
if sys.platform == "win32":
# Ensure text entries are visible with windows combo boxes
editor.setMinimumHeight(self.sizeHint(option, index).height() + 10)
editor.addItems(self.items)
if self.is_editable:
editor.setEditable(True)
editor.setInsertPolicy(QComboBox.NoInsert)
if self.current_edit_text:
editor.setEditText(self.current_edit_text)
if self.colors:
img = QImage(16, 16, QImage.Format_RGB32)
painter = QPainter(img)
painter.fillRect(img.rect(), Qt.black)
rect = img.rect().adjusted(1, 1, -1, -1)
for i, item in enumerate(self.items):
color = self.colors[i]
painter.fillRect(rect, QColor(color.red(), color.green(), color.blue(), 255))
editor.setItemData(i, QPixmap.fromImage(img), Qt.DecorationRole)
del painter
editor.currentIndexChanged.connect(self.currentIndexChanged)
editor.editTextChanged.connect(self.on_edit_text_changed)
return editor
class Example(QWidget):
def __init__(self):
super().__init__()
self.n = 1
self.filename = QFileDialog.getOpenFileName(self,
'Выбрать файл L-системы',
'/')[0]
self.initUI()
def initUI(self):
self.setGeometry(500, 500, *SCREEN_SIZE)
self.setWindowTitle('L - системы')
self.flag = False
self.slider = QSlider(Qt.Horizontal, self)
self.slider.move(25, 480)
self.slider.valueChanged.connect(self.draw)
self.slider.setMinimum(1)
self.slider.setMaximum(10)
self.slider.setFixedWidth(450)
self.show()
def draw(self, value):
self.flag = True
self.n = value
qp = QPainter()
qp.begin(self)
self.qp = QPainter()
self.qp.begin(self)
self.drawL()
self.qp.end()
qp.end()
self.update()
self.show()
def paintEvent(self, e):
if self.flag:
qp = QPainter()
qp.begin(self)
self.qp = QPainter()
self.qp.begin(self)
self.drawL()
self.qp.end()
qp.end()
def moveto(self, x, y):
self.graph_pos[0] = x
self.graph_pos[1] = y
def lineto(self, x, y):
self.qp.drawLine(*self.graph_pos, int(x), int(y))
self.graph_pos[0] = int(x)
self.graph_pos[1] = int(y)
# Построение L-системы по L-строке
def plotlsystem(self, lstring):
for ch in lstring:
if ch == "F":
self.POSITION[0] += self.step * cos(radians(self.POSITION[2]))
self.POSITION[1] += self.step * sin(radians(self.POSITION[2]))
self.lineto(xs(self.POSITION[0]), ys(self.POSITION[1]))
elif ch == "f":
self.POSITION[0] += self.step * cos(radians(self.POSITION[2]))
self.POSITION[1] += self.step * sin(radians(self.POSITION[2]))
self.lineto(xs(self.POSITION[0]), ys(self.POSITION[1]))
elif ch == "-":
self.POSITION[2] += LSystem["ANGLE"]
elif ch == "+":
self.POSITION[2] -= LSystem["ANGLE"]
elif ch == "[":
STACK.append(self.POSITION[:])
elif ch == "]":
if STACK:
self.POSITION[0], self.POSITION[1], self.POSITION[
2] = STACK.pop(-1)
self.moveto(xs(self.POSITION[0]), ys(self.POSITION[1]))
def drawL(self):
readlsystem(self.filename)
x, y = 0, 0
self.step = 20
self.POSITION = [x, y, 0]
self.graph_pos = [xs(x), xs(y)]
self.plotlsystem(buildlsystem(self.n))
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
if self.backgroundColor == 'default':
painter.fillRect(event.rect(),
self.palette().brush(QPalette.Window))
else:
size = self.size()
center_x = size.width() / 2
diameter = size.height()
brush = QBrush(QColor(self.backgroundColor), Qtc.SolidPattern)
painter.setBrush(brush)
painter.setPen(QPen(QColor(self.scaleColor), 2))
painter.setRenderHint(QPainter.Antialiasing)
painter.drawEllipse(center_x - diameter / 2 + 1, 1, diameter - 4,
diameter - 4)
self.drawMarkings(painter)
self.drawNeedle(painter)
painter.end()
def paintEvent(self, event):
linePen = QPen(Qt.black)
linePen.setWidth(3)
width = self.width() / self.scale
def paintLineMarks(painter):
painter.save()
painter.scale(self.scale, yDirection * self.scale)
painter.setPen(linePen)
painter.drawLine(0, self.ascender, width, self.ascender)
painter.drawLine(0, 0, width, 0)
painter.drawLine(0, self.descender, width, self.descender)
painter.restore()
painter = QPainter(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.fillRect(0, 0, self.width(), self.height(), Qt.white)
if self._verticalFlip:
baselineShift = -self.descender
yDirection = 1
else:
baselineShift = self.ascender
yDirection = -1
painter.translate(
self.padding,
self.padding + baselineShift * self.scale * self._lineHeight)
# TODO: scale painter here to avoid g*scale everywhere below
cur_width = 0
if self._showMetrics:
paintLineMarks(painter)
for index, glyph in enumerate(self.glyphs):
# line wrapping
gWidth = glyph.width * self.scale
doKern = index > 0 and self._showKerning and cur_width > 0
if doKern:
kern = self.lookupKerningValue(self.glyphs[index - 1].name,
glyph.name) * self.scale
else:
kern = 0
if (self._wrapLines and cur_width + gWidth + kern +
2 * self.padding > self.width()) or glyph.unicode == 2029:
painter.translate(-cur_width, self.ptSize * self._lineHeight)
if self._showMetrics:
paintLineMarks(painter)
cur_width = gWidth
else:
if doKern:
painter.translate(kern, 0)
cur_width += gWidth + kern
glyphPath = glyph.getRepresentation("defconQt.QPainterPath")
painter.save()
painter.scale(self.scale, yDirection * self.scale)
if self._showMetrics:
halfDescent = self.descender / 2
painter.drawLine(0, 0, 0, halfDescent)
painter.drawLine(glyph.width, 0, glyph.width, halfDescent)
if self._selected is not None and index == self._selected:
painter.fillRect(0, self.descender, glyph.width, self.upm,
glyphSelectionColor)
painter.fillPath(glyphPath, Qt.black)
painter.restore()
painter.translate(gWidth, 0)
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
self.drawImages(painter)
painter.end()
def paintEvent(self, event):
background = QRadialGradient(QPointF(self.rect().topLeft()), 500,
QPointF(self.rect().bottomRight()))
background.setColorAt(0, self.backgroundColor1)
background.setColorAt(1, self.backgroundColor2)
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
painter.fillRect(event.rect(), QBrush(background))
painter.setPen(self.pen)
for bubble in self.bubbles:
if QRectF(
bubble.position - QPointF(bubble.radius, bubble.radius),
QSizeF(2 * bubble.radius, 2 * bubble.radius),
).intersects(QRectF(event.rect())):
bubble.drawBubble(painter)
if self.newBubble:
self.newBubble.drawBubble(painter)
painter.end()
class RenderWindow(QWidget):
def __init__(self):
windowSettings = self.loadSettings()
self.width = windowSettings["ImageWidth"]
self.height = windowSettings["ImageHeight"]
super().__init__()
self.setFixedSize(self.width, self.height)
self.move(200, 200)
self.setWindowTitle('RayTracing')
self.showBuckets = True # show bucket switch
self.bgImage = QImage(self.width, self.height,
4) # QImage.Format_RGB32
self.bgImage.fill(QColor(0, 0,
0)) # important, give canvas a default color
self.bucketLocator = QImage(
"bucketLocator.png") # Bucket Locator Image
self.graphic = QGraphicsScene(0, 0, self.width, self.height, self)
self.canvasPixmap = QPixmap().fromImage(self.bgImage)
self.canvasPainter = QPainter(self.canvasPixmap)
# Render image pixmap and painter
self.renderImagePixmap = QPixmap().fromImage(self.bgImage)
self.renderImagePainter = QPainter(self.renderImagePixmap)
# BuckerLocators pixmap and painter
self.locatorPixmap = QPixmap().fromImage(self.bgImage)
self.locatorPainter = QPainter(self.locatorPixmap)
self.graphicItem = self.graphic.addPixmap(self.canvasPixmap)
self.graphicView = QGraphicsView(self.graphic, self)
self.show()
def loadSettings(self):
with open("RenderSettings.json") as settingsData:
renderSettings = json.load(settingsData)
return renderSettings["RenderWindow"]
def keyPressEvent(self, event):
if event.key() == Qt.Key_S:
self.saveImage()
elif event.key() == Qt.Key_H:
if self.showBuckets:
self.showBuckets = False
print("Hide Buckets")
else:
self.showBuckets = True
print("Show Buckets")
self.refreshCanvas()
def startRender(self, scene, cam):
# start render in a new thread
self.renderTask = RenderThread(self.width, self.height, scene, cam)
self.renderTask.updateImgSignal.connect(self.updateRenderImage)
self.renderTask.bucketProgressSignal.connect(self.showBucketProgess)
self.renderTask.finished.connect(self.cleanBucketLocators)
self.renderTask.finished.connect(self.saveImage)
self.renderTask.start()
def cleanBucketLocators(self):
self.locatorPainter.drawImage(0, 0, self.bgImage)
self.refreshCanvas()
def showBucketProgess(self, bucketProgressPos):
bucketSize = bucketProgressPos[2]
if len(bucketProgressPos) > 3:
blackPatch = QImage(bucketSize, bucketSize, 4)
blackPatch.fill(0)
self.locatorPainter.drawImage(bucketProgressPos[3],
bucketProgressPos[4], blackPatch)
bucketLocImg = self.bucketLocator.scaled(bucketSize, bucketSize)
self.locatorPainter.drawImage(bucketProgressPos[0],
bucketProgressPos[1], bucketLocImg)
self.refreshCanvas()
def updateRenderImage(self, bucketDataList):
# update the render view, note the render is in another thread]
# use QPainter to stamp the image to canvas
self.renderImagePainter.drawImage(bucketDataList[0], bucketDataList[1],
bucketDataList[2])
self.refreshCanvas()
def refreshCanvas(self):
self.canvasPainter.drawPixmap(0, 0, self.renderImagePixmap)
if self.showBuckets:
self.canvasPainter.setCompositionMode(
12) # plus locator layer on top
self.canvasPainter.drawPixmap(0, 0, self.locatorPixmap)
self.canvasPainter.setCompositionMode(
0) # set comp mode back to over
self.graphicItem.setPixmap(self.canvasPixmap)
def saveImage(self):
self.canvasPixmap.save("Render10.png")
print("Image Saved")
def paintEvent(self, QPaintEvent):
qp = QPainter()
qp.begin(self)
self.circles(qp)
qp.end()
def paintEvent(self, event):
painter = QPainter(self)
painter.drawPixmap(self.rect(), self.bgImage)
def paintEvent(self, event):
opt = QStyleOption()
opt.initFrom(self)
painter = QPainter(self)
self.style().drawPrimitive(QStyle.PE_Widget, opt, painter, self)
def paintEvent(self, event): ##绘制窗口背景图片
painter = QPainter(self)
pic = QPixmap("sea1.jpg")
painter.drawPixmap(0, 0, self.width(), self.height(), pic)
def idleStuff(self):
if self.fPipeClient is not None:
gCarla.utils.pipe_client_idle(self.fPipeClient)
self.checkForRepaintChanges()
if self.fSizeSetup:
return
if self.fDocElemement is None or self.fDocElemement.isNull():
return
pedal = self.fDocElemement.findFirst(".mod-pedal")
if pedal.isNull():
return
size = pedal.geometry().size()
if size.width() <= 10 or size.height() <= 10:
return
# render web frame to image
image = QImage(self.fWebview.page().viewportSize(),
QImage.Format_ARGB32_Premultiplied)
image.fill(Qt.transparent)
painter = QPainter(image)
self.fCurrentFrame.render(painter)
painter.end()
#image.save("/tmp/test.png")
# get coordinates and size from image
#x = -1
#y = -1
#lastx = -1
#lasty = -1
#bgcol = self.fHostColor.rgba()
#for h in range(0, image.height()):
#hasNonTransPixels = False
#for w in range(0, image.width()):
#if image.pixel(w, h) not in (0, bgcol): # 0xff070707):
#hasNonTransPixels = True
#if x == -1 or x > w:
#x = w
#lastx = max(lastx, w)
#if hasNonTransPixels:
##if y == -1:
##y = h
#lasty = h
# set size and position accordingly
#if -1 not in (x, lastx, lasty):
#self.setFixedSize(lastx-x, lasty)
#self.fCurrentFrame.setScrollPosition(QPoint(x, 0))
#else:
# TODO that^ needs work
if True:
self.setFixedSize(size)
# set initial values
self.fCurrentFrame.evaluateJavaScript(
"icongui.setPortValue(':bypass', 0, null)")
for index in self.fPortValues.keys():
symbol, isOutput = self.fPortSymbols[index]
value = self.fPortValues[index]
if isOutput:
self.fCurrentFrame.evaluateJavaScript(
"icongui.setOutputPortValue('%s', %f)" % (symbol, value))
else:
self.fCurrentFrame.evaluateJavaScript(
"icongui.setPortValue('%s', %f, null)" % (symbol, value))
# final setup
self.fCanSetValues = True
self.fSizeSetup = True
self.fDocElemement = None
if self.fNeedsShow:
self.show()
def paintEvent(self, event):
painter = QPainter(self)
event.accept()
# -------------------------------------------------------------
# Paint clean keys (as background)
for octave in range(self.fOctaves):
target = QRectF(self.fWidth * octave, 0, self.fWidth, self.fHeight)
source = QRectF(0, 0, self.fWidth, self.fHeight)
painter.drawPixmap(target, self.fPixmapNormal, source)
if not self.isEnabled():
painter.setBrush(QColor(0, 0, 0, 150))
painter.setPen(QColor(0, 0, 0, 150))
painter.drawRect(0, 0, self.width(), self.height())
return
# -------------------------------------------------------------
# Paint (white) pressed keys
paintedWhite = False
for note in self.fEnabledKeys:
pos = self._getRectFromMidiNote(note)
if self._isNoteBlack(note):
continue
if note < 12:
octave = 0
elif note < 24:
octave = 1
elif note < 36:
octave = 2
elif note < 48:
octave = 3
elif note < 60:
octave = 4
elif note < 72:
octave = 5
elif note < 84:
octave = 6
elif note < 96:
octave = 7
elif note < 108:
octave = 8
elif note < 120:
octave = 9
elif note < 132:
octave = 10
else:
# cannot paint this note
continue
octave -= self.fStartOctave
target = QRectF(pos.x() + (self.fWidth * octave), 0, pos.width(), pos.height())
source = QRectF(pos.x(), 0, pos.width(), pos.height())
paintedWhite = True
painter.drawPixmap(target, self.fPixmapDown, source)
# -------------------------------------------------------------
# Clear white keys border
if paintedWhite:
for octave in range(self.fOctaves):
for note in kBlackNotes:
pos = self._getRectFromMidiNote(note)
target = QRectF(pos.x() + (self.fWidth * octave), 0, pos.width(), pos.height())
source = QRectF(pos.x(), 0, pos.width(), pos.height())
painter.drawPixmap(target, self.fPixmapNormal, source)
# -------------------------------------------------------------
# Paint (black) pressed keys
for note in self.fEnabledKeys:
pos = self._getRectFromMidiNote(note)
if not self._isNoteBlack(note):
continue
if note < 12:
octave = 0
elif note < 24:
octave = 1
elif note < 36:
octave = 2
elif note < 48:
octave = 3
elif note < 60:
octave = 4
elif note < 72:
octave = 5
elif note < 84:
octave = 6
elif note < 96:
octave = 7
elif note < 108:
octave = 8
elif note < 120:
octave = 9
elif note < 132:
octave = 10
else:
# cannot paint this note
continue
octave -= self.fStartOctave
target = QRectF(pos.x() + (self.fWidth * octave), 0, pos.width(), pos.height())
source = QRectF(pos.x(), 0, pos.width(), pos.height())
painter.drawPixmap(target, self.fPixmapDown, source)
# Paint C-number note info
painter.setFont(self.fFont)
painter.setPen(Qt.black)
for i in range(self.fOctaves):
octave = self.fStartOctave + i - 1
painter.drawText(i * 168 + (4 if octave == -1 else 3),
35, 20, 20,
Qt.AlignCenter,
"C{}".format(octave))
def drawControl(
self,
element: QStyle.ControlElement,
opt: Union[QStyleOption, QStyleOptionToolButton],
p: QPainter,
widget: QWidget,
):
if element == QStyle.CE_ToolButtonLabel:
toolbutton = opt
rect = toolbutton.rect
shift_x = 0
shift_y = 0
if toolbutton.state & (QStyle.State_Sunken | QStyle.State_On): # type: ignore
shift_x = super(TTToolButtonStyle, self).pixelMetric(
QStyle.PM_ButtonShiftHorizontal, toolbutton, widget
)
shift_y = super(TTToolButtonStyle, self).pixelMetric(
QStyle.PM_ButtonShiftVertical, toolbutton, widget
)
has_arrow = bool(toolbutton.features & QStyleOptionToolButton.Arrow) # type: ignore
if (
(not has_arrow and toolbutton.icon.isNull()) and toolbutton.text # type: ignore
) or toolbutton.toolButtonStyle == QtCore.Qt.ToolButtonTextOnly: # type: ignore
alignment = (
QtCore.Qt.AlignTop
| QtCore.Qt.AlignHCenter
| QtCore.Qt.TextShowMnemonic
)
if not self.proxy().styleHint(QStyle.SH_UnderlineShortcut, opt, widget):
alignment |= QtCore.Qt.TextHideMnemonic
rect.translate(shift_x, shift_y)
p.setFont(toolbutton.font) # type: ignore
self.proxy().drawItemText(
p,
rect,
alignment,
toolbutton.palette,
bool(opt.state & QStyle.State_Enabled), # type: ignore
toolbutton.text, # type: ignore
QPalette.ButtonText,
)
else:
pm = QPixmap()
pm_size = toolbutton.iconSize # type: ignore
if not toolbutton.icon.isNull(): # type: ignore
state = (
QIcon.On if (toolbutton.state & QStyle.State_On) else QIcon.Off # type: ignore
)
mode = QIcon().Mode
if not toolbutton.state & QStyle.State_Enabled: # type: ignore
mode = QIcon.Disabled
elif (opt.state & QStyle.State_MouseOver) and ( # type: ignore
opt.state & QStyle.State_AutoRaise
):
mode = QIcon.Active
else:
mode = QIcon.Normal
pm = toolbutton.icon.pixmap( # type: ignore
toolbutton.rect.size().boundedTo(toolbutton.iconSize), # type: ignore
mode,
state,
)
pm_size = pm.size()
if toolbutton.toolButtonStyle != QtCore.Qt.ToolButtonIconOnly: # type: ignore
p.setFont(toolbutton.font) # type: ignore
pr = QtCore.QRect(rect)
tr = QtCore.QRect(rect)
alignment = QtCore.Qt.TextShowMnemonic
if not self.proxy().styleHint(
QStyle.SH_UnderlineShortcut, opt, widget
):
alignment |= QtCore.Qt.TextHideMnemonic
if toolbutton.toolButtonStyle == QtCore.Qt.ToolButtonTextUnderIcon: # type: ignore
pr.setHeight(pm_size.height() + 6)
tr.adjust(0, pr.height() - 1, 0, -2)
pr.translate(shift_x, shift_y)
if not has_arrow:
self.proxy().drawItemPixmap(
p,
pr,
int(QtCore.Qt.AlignTop | QtCore.Qt.AlignHCenter),
pm,
)
alignment |= int(QtCore.Qt.AlignTop | QtCore.Qt.AlignHCenter)
else:
pr.setWidth(pm_size.width() + 8)
tr.adjust(pr.width(), 0, 0, 0)
pr.translate(shift_x, shift_y)
if not has_arrow:
self.proxy().drawItemPixmap(
p,
QStyle.visualRect(opt.direction, rect, pr),
QtCore.Qt.AlignTop | QtCore.Qt.AlignHCenter,
pm,
)
alignment |= int(QtCore.Qt.AlignTop) | int(
QtCore.Qt.AlignHCenter
)
tr.translate(shift_x, shift_y)
self.proxy().drawItemText(
p,
QStyle.visualRect(opt.direction, rect, tr),
alignment,
toolbutton.palette,
bool(toolbutton.state & QStyle.State_Enabled), # type: ignore
toolbutton.text, # type: ignore
QPalette.ButtonText,
)
else:
rect.translate(shift_x, shift_y)
if not has_arrow:
self.proxy().drawItemPixmap(
p, rect, QtCore.Qt.AlignTop | QtCore.Qt.AlignHCenter, pm
)
return
super(TTToolButtonStyle, self).drawControl(element, opt, p, widget)
def paintEvent(self, event):
self.qp = QPainter()
self.qp.begin(self)
for obj in self.objects:
obj.draw(self.qp)
self.qp.end()
def paintEvent(self, event):
painter = QPainter(self)
painter.setFont(UIFont)
painter.setRenderHint(QPainter.Antialiasing)
# draw the background
self._glyphRecordsRects = {}
painter.fillRect(event.rect(), self._backgroundColor)
if not self._glyphRecords:
return
# move into the canvas origin
offset = self._drawingOffset
painter.translate(offset)
painter.scale(self._scale, -self._scale)
left = offset.x()
top = offset.y() - self._ascender * self._scale
height = self._unitsPerEm * self._scale
painter.save()
for recordIndex, glyphRecord in enumerate(self._glyphRecords):
active = recordIndex == self._activeIndex
xO = glyphRecord.xOffset
yO = glyphRecord.yOffset
xA = glyphRecord.xAdvance
yA = glyphRecord.yAdvance
# store the glyph rect
top -= yO * self._scale
glyphHeight = height + yA * self._scale
glyphLeft = left + xO * self._scale
glyphWidth = xA * self._scale
rect = (glyphLeft, top, glyphWidth, glyphHeight)
self._glyphRecordsRects[rect] = recordIndex
# handle placement
if xO or yO:
painter.translate(xO, yO)
# draw the background
painter.save()
foreGlyph = glyphRecord.glyph
foreGlyph = foreGlyph.font[foreGlyph.name]
self.drawGlyphBackground(painter, foreGlyph, GlyphFlags(active))
self.drawBackground(painter, recordIndex)
painter.restore()
# shift for the next glyph
painter.translate(xA - xO, yA - yO)
left += glyphWidth
painter.restore()
for recordIndex, glyphRecord in enumerate(self._glyphRecords):
glyph = glyphRecord.glyph
xO = glyphRecord.xOffset
yO = glyphRecord.yOffset
xA = glyphRecord.xAdvance
yA = glyphRecord.yAdvance
# gather the crowd
layerSet = glyph.layerSet
if layerSet is None:
layers = [(glyph, GlyphFlags(True))]
else:
layers = []
for layerName in reversed(layerSet.layerOrder):
layer = layerSet[layerName]
if glyph.name in layer:
layerGlyph = layer[glyph.name]
layerFlags = GlyphFlags(
recordIndex == self._activeIndex, layerGlyph == glyph
)
layers.append((layerGlyph, layerFlags))
# handle placement
if xO or yO:
painter.translate(xO, yO)
# draw layers and foreground
painter.save()
for layerGlyph, layerFlags in layers:
self.drawGlyphLayer(painter, layerGlyph, layerFlags)
self.drawForeground(painter, recordIndex)
painter.restore()
# shift for the next glyph
painter.translate(xA - xO, yA - yO)
def paintEvent(self, event):
bgcolor = self.palette().color(QPalette.Background)
pen = QPen(bgcolor, 7, Qt.SolidLine)
qp = QPainter()
qp.begin(self)
qp.setPen(pen)
qp.setRenderHint(QPainter.Antialiasing)
qp.setBrush(Qt.gray)
for i in range(self.n):
alpha = int(16 * 360 * i / self.n)
alpha2 = int(16 * 360 * 1 / self.n)
qp.setBrush(Qt.green if i < self.m else Qt.gray)
qp.drawPie(self.R, alpha, alpha2)
qp.end()
def paintEvent(self, paint_event):
painter = QPainter(self)
painter.drawImage(self.rect(), self.image)
def paintEvent(self, event):
painter = QPainter()
painter.begin(self)
painter.setRenderHint(QPainter.Antialiasing)
self.helper.paint(painter, event, self.elapsed)
painter.end()
def paintEvent(self, e): super().paintEvent(e) painter = QPainter(self.viewport()) painter.end()
def producer_repetitive_scope_test(
path,
repetitions=1,
delay=0): # producer with repetitive writes to shared memory
import time
from PyQt5.QtGui import QPainter, QPixmap, QColor, QFont, QPen
from PyQt5.QtCore import Qt
from prodcon_ipc.producer_ipc import ProducerIPC
# FIXME: this is still buggy because when the images are not read sufficiently fast from the consumer (which
# only (?) happens in the non-async Python consumer), image data gets corrupted (may be overwritten by the
# producer?! but this SHOULD be prevented by the system semaphores and the producer/consumer sync...)
producer_ipc = ProducerIPC(UNIQUE_SHARED_MEMORY_NAME,
SHARED_MEMORY_KEY_FILE)
for i in range(repetitions):
image = QImage()
if not image.load(path):
logzero.logger.error("Unable to load image " + path)
sys.exit(1)
else:
pm = QPixmap.fromImage(
image) # .convertToFormat(QImage.Format_RGB32)
p = QPainter()
p.begin(pm)
p.setPen(QPen(Qt.yellow))
p.setFont(QFont("Times", 20, QFont.Bold))
p.drawText(pm.rect(), Qt.AlignCenter,
str(i + 1) + " of " + str(repetitions))
p.end()
image = pm.toImage()
# Load the image:
buf = QBuffer()
buf.open(QBuffer.ReadWrite)
out = QDataStream(buf)
out << image
try:
avail_size, mem_data = producer_ipc.begin(buf.size())
if avail_size < buf.size():
logzero.logger.warn("Couldn't get enough memory!")
except RuntimeError as err:
logzero.logger.error(str(err))
sys.exit(2)
# Copy image data from buf into shared memory area:
error_str = None
try:
mem_data[:avail_size] = buf.data().data()[:avail_size]
except Exception as err:
logzero.logger.error(str(err))
try:
producer_ipc.end()
except RuntimeError as err:
logzero.logger.error(str(err))
sys.exit(3)
if delay > 0:
time.sleep(delay)
logzero.logger.debug("Iteration " + str(i + 1) + " of " +
str(repetitions) + " completed.")
logzero.logger.info("All okay")
# IMPORTANT: The object should NOT go out of scope until the consumer has read the data, so (also) dont call:
# del producer_ipc
# ...or let the app exit right away. That's why we do here:
try:
input(
"Press Enter to exit but let the consumer read the image first...")
except:
sys.stdout.write("\n")
pass
sys.exit(0)
stoneColor = Qt.red
stoneY = playerY - stoneHeight
imageCrop = 300
imageResize = (80, 30)
# till here
all_data = numpy.load('modelData.npy')
#all_data = all_data[10:20]
img_data = []
output = []
image = QImage(screenWidth, screenHeight, QImage.Format_RGB32)
painter = QPainter(image)
for data in tqdm(all_data):
target_dist = data[0]
bar_dist = data[1]
player1X = barPosX - bar_dist
player2X = player1X + target_dist
stoneX = player2X + playerWidth - stoneWidth
#draw
image.fill(Qt.white)
painter.fillRect(0, screenHeight - fieldHeight, screenWidth, fieldHeight,
fieldColor)
painter.fillRect(barPosX, barPosY, barWidth, barHeight, fieldColor)
def paintEvent(self, event):
qp = QPainter(self)
qp.setPen(Qt.black)
size = self.size()
# Colored rectangles
qp.setBrush(QColor(200, 0, 0))
qp.drawRect(0, 0, 100, 100)
qp.setBrush(QColor(0, 200, 0))
qp.drawRect(100, 0, 100, 100)
qp.setBrush(QColor(0, 0, 200))
qp.drawRect(200, 0, 100, 100)
# Color Effect
for i in range(0, 100):
qp.setBrush(QColor(i * 10, 0, 0))
qp.drawRect(10 * i, 100, 10, 32)
qp.setBrush(QColor(i * 10, i * 10, 0))
qp.drawRect(10 * i, 100 + 32, 10, 32)
qp.setBrush(QColor(i * 2, i * 10, i * 1))
qp.drawRect(10 * i, 100 + 64, 10, 32)
class Example(QMainWindow):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.setGeometry(300, 300, 600, 600)
self.setWindowTitle('Drawing home')
self.width = 175 #default settings
self.height = 100
self.roofHeight = 50
self.mainColor1 = QColor(255, 255, 127)
self.mainColor2 = QColor(255, 85, 0)
self.roofColor = QColor(199, 250, 252)
self.doorColor = QColor(255, 255, 255)
self.lightColor = QColor(255, 219, 41)
self.windowStyle = "Round window"
self.roomNumber = 1
drawButton = QPushButton(
"Move cursor here to update the object, if it was not happened",
self)
drawButton.setFont(QFont("Comic Sans MS", 11, QFont.Normal))
drawButton.move(40, 60)
drawButton.adjustSize()
#sliders etc.
self.changeWidth = QSlider(Qt.Horizontal, self)
self.changeWidth.setFocusPolicy(Qt.NoFocus)
self.changeWidth.setStyleSheet(sldStyle) #use our own style!
self.changeWidth.setGeometry(30, 150, 100, 30)
self.changeWidth.valueChanged[int].connect(self.changeWidthF)
self.changeHeight = QSlider(Qt.Horizontal, self)
self.changeHeight.setFocusPolicy(Qt.NoFocus)
self.changeHeight.setStyleSheet(sldStyle)
self.changeHeight.setGeometry(30, 220, 100, 30)
self.changeHeight.valueChanged[int].connect(self.changeHeightF)
self.changeRoofHeight = QSlider(Qt.Horizontal, self)
self.changeRoofHeight.setFocusPolicy(Qt.NoFocus)
self.changeRoofHeight.setStyleSheet(sldStyle)
self.changeRoofHeight.setGeometry(30, 290, 100, 30)
self.changeRoofHeight.valueChanged[int].connect(self.changeRoofHeightF)
changeWindowStyle = QComboBox(self)
changeWindowStyle.addItem("Round window")
changeWindowStyle.addItem("2-part window")
changeWindowStyle.addItem("No window")
changeWindowStyle.move(30, 365)
changeWindowStyle.setFont(QFont("Tahoma", 10, QFont.Normal))
changeWindowStyle.activated[str].connect(self.changeWindowStyle)
changeWindowStyle.adjustSize()
changeIllumination = QCheckBox('Neon Light', self)
changeIllumination.move(30, 410)
changeIllumination.setFont(QFont("Segoe Print", 10, QFont.Normal))
changeIllumination.adjustSize()
changeIllumination.stateChanged.connect(self.changeIllumination)
changeRoomNumber = QComboBox(self)
changeRoomNumber.addItem("1")
changeRoomNumber.addItem("2")
changeRoomNumber.move(30, 505)
changeRoomNumber.setFont(QFont("Tahoma", 10, QFont.Normal))
changeRoomNumber.activated[int].connect(self.changeRoomNumber)
#labels
changeW = QLabel("Width", self)
changeW.move(30, 120)
changeW.setFont(QFont("Segoe Print", 10, QFont.Normal))
changeH = QLabel("Height", self)
changeH.move(30, 190)
changeH.setFont(QFont("Segoe Print", 10, QFont.Normal))
changeRH = QLabel("Roof level", self)
changeRH.move(30, 260)
changeRH.setFont(QFont("Segoe Print", 10, QFont.Normal))
changeWS = QLabel("Window style", self)
changeWS.move(30, 330)
changeWS.setFont(QFont("Segoe Print", 10, QFont.Normal))
changeWS.adjustSize()
changeRN = QLabel("Number of rooms", self)
changeRN.move(30, 450)
changeRN.setFont(QFont("Segoe Print", 10, QFont.Normal))
changeRN.adjustSize()
changeRN1 = QLabel("on the 2nd floor", self)
changeRN1.move(30, 470)
changeRN1.setFont(QFont("Segoe Print", 10, QFont.Normal))
changeRN1.adjustSize()
#toolbar actions
roofColorAction = QAction(QIcon('colorR.png'),
'Change color of the roof', self)
roofColorAction.triggered.connect(self.changeRoofColor)
color1Action = QAction(QIcon('color2.png'),
'Change color of the upper part', self)
color1Action.triggered.connect(self.changeColor1)
color2Action = QAction(QIcon('color1.png'),
'Change color of the lower part', self)
color2Action.triggered.connect(self.changeColor2)
doorColorAction = QAction(QIcon('colorD.png'),
'Change color of the door', self)
doorColorAction.triggered.connect(self.changeDoorColor)
randomizeAction = QAction(QIcon('random.png'), 'Randonize your house',
self)
randomizeAction.triggered.connect(self.randomize)
toolbar = self.addToolBar('Menu')
toolbar.setIconSize(QSize(45, 45))
toolbar.addAction(roofColorAction)
toolbar.addAction(color2Action)
toolbar.addAction(color1Action)
toolbar.addAction(doorColorAction)
toolbar.addAction(randomizeAction)
self.show()
def paintEvent(self, e):
#print("paint")
self.qp = QPainter(self)
#self.qp.setPen(QColor(245, 245, 245)) #if you need no black circuit
triangle = QPolygonF([
QPointF(200, 200),
QPointF(200 + self.width, 200),
QPointF(200 + self.width / 2, 200 - self.roofHeight)
])
self.qp.setBrush(QBrush(self.roofColor, Qt.SolidPattern))
self.qp.drawPolygon(triangle) #roof
self.qp.setBrush(QBrush(self.mainColor1, Qt.SolidPattern))
self.qp.drawRect(200, 200, self.width, self.height) #upper part
self.qp.setBrush(QBrush(self.mainColor2, Qt.SolidPattern))
self.qp.drawRect(200, 200 + self.height, self.width,
self.height) #lower part
#details
self.qp.setBrush(QBrush(self.doorColor, Qt.SolidPattern))
self.qp.drawRect(130 + self.width, 115 + 2 * self.height, 50,
80) #calculate door
self.qp.setBrush(QBrush(self.lightColor, Qt.SolidPattern))
self.qp.drawRect(140 + self.width, 125 + 2 * self.height, 30,
40) #window on the door
self.qp.setBrush(QBrush(QColor(173, 98, 23), Qt.SolidPattern))
self.qp.drawEllipse(173 + self.width, 160 + 2 * self.height, 4,
4) #door handle
#variants of the window on the third floor
self.qp.setBrush(QBrush(self.lightColor, Qt.SolidPattern))
if self.windowStyle == "Round window":
diameter = 30 * (self.roofHeight / 50) #calculate proportion
if diameter > 45:
diameter = 45 #limit for normal design
self.qp.drawEllipse(200 - diameter / 2 + self.width / 2,
200 - diameter / 2 - self.roofHeight * 0.45,
diameter, diameter)
self.qp.setPen(QPen(QColor(173, 98, 23), 3,
Qt.SolidLine)) #window planks
self.qp.drawLine(202 - diameter / 2 + self.width / 2,
200 - self.roofHeight * 0.45,
198 + diameter / 2 + self.width / 2,
200 - self.roofHeight * 0.45)
self.qp.drawLine(200 + self.width / 2,
198 + diameter / 2 - self.roofHeight * 0.45,
200 + self.width / 2,
202 - diameter / 2 - self.roofHeight * 0.45)
if self.windowStyle == "2-part window":
left = QPolygonF([
QPointF(200 + self.width / 3, 195),
QPointF(197 + self.width / 2, 195),
QPointF(197 + self.width / 2, 210 - self.roofHeight / 1.04),
QPointF(200 + self.width / 3, 210 - self.roofHeight / 1.5)
])
self.qp.drawPolygon(left)
right = QPolygonF([
QPointF(200 + self.width * 2 / 3, 195),
QPointF(203 + self.width / 2, 195),
QPointF(203 + self.width / 2, 210 - self.roofHeight / 1.04),
QPointF(200 + self.width * 2 / 3, 210 - self.roofHeight / 1.5)
])
self.qp.drawPolygon(right)
#window on the first floor
self.qp.setPen(QPen(Qt.black, 1, Qt.SolidLine))
self.qp.drawRect(210 + 2 / 5 * (self.width - 175),
110 + 2 * self.height - 1 / 5 * (self.height - 100),
75 + 2 / 5 * (self.width - 175),
65 + 1 / 5 * (self.height - 100))
xc = 210 + 2 / 5 * (self.width - 175) + (75 + 2 / 5 *
(self.width - 175)) / 2
yc = 110 + 2 * self.height - 1 / 5 * (self.height -
100) + (65 + 1 / 5 *
(self.height - 100)) / 2
xr = 208 + 2 / 5 * (self.width - 175) + 75 + 2 / 5 * (self.width - 175)
yd = 108 + 2 * self.height - 1 / 5 * (
self.height - 100) + 65 + 1 / 5 * (self.height - 100)
self.qp.setPen(QPen(QColor(173, 98, 23), 3, Qt.SolidLine))
self.qp.drawLine(212 + 2 / 5 * (self.width - 175), yc, xr, yc)
self.qp.drawLine(xc,
112 + 2 * self.height - 1 / 5 * (self.height - 100),
xc, yd)
#windows on the second floor
self.qp.setPen(QPen(Qt.black, 1, Qt.SolidLine))
yc = 110 + self.height - 1 / 5 * (self.height - 100)
yd = 65 + 1 / 5 * (
self.height - 100
) #use our previous variables to make arguments shorter
if self.roomNumber == 1:
self.qp.drawRect(200 + self.width * 0.2, yc, self.width * 0.6, yd)
self.qp.setPen(QPen(QColor(173, 98, 23), 3, Qt.SolidLine))
self.qp.drawLine(200 + self.width * 0.4, yc + 2,
200 + self.width * 0.4, yc + yd - 2)
self.qp.drawLine(200 + self.width * 0.6, yc + 2,
200 + self.width * 0.6, yc + yd - 2)
if self.roomNumber == 2:
self.qp.drawRect(200 + self.width * 0.1, yc, self.width * 0.35, yd)
self.qp.drawRect(200 + self.width * 0.55, yc, self.width * 0.35,
yd)
self.qp.setPen(QPen(QColor(173, 98, 23), 3, Qt.SolidLine))
self.qp.drawLine(200 + self.width * 0.275, yc + 2,
200 + self.width * 0.275, yc + yd - 2)
self.qp.drawLine(200 + self.width * 0.725, yc + 2,
200 + self.width * 0.725, yc + yd - 2)
self.qp.end()
self.update() #need to draw again our image
def changeRoofColor(self):
roofColor = QColorDialog.getColor()
if roofColor.isValid():
self.roofColor = roofColor
def changeColor1(self):
mainColor1 = QColorDialog.getColor()
if mainColor1.isValid():
self.mainColor1 = mainColor1
def changeColor2(self):
mainColor2 = QColorDialog.getColor()
if mainColor2.isValid():
self.mainColor2 = mainColor2
def changeDoorColor(self):
doorColor = QColorDialog.getColor()
if doorColor.isValid():
self.doorColor = doorColor
def changeWidthF(self, value):
#print("changed to " + str(value + 150))
self.width = value + 175
def changeHeightF(self, value):
self.height = value / 2 + 100 #keep in mind max and min value of each characteristic
def changeRoofHeightF(self, value):
self.roofHeight = value / 2 + 50
def changeWindowStyle(self, text):
self.windowStyle = text
def changeIllumination(self, state):
if state == Qt.Checked:
self.lightColor = QColor(229, 101, 157) #purple
else:
self.lightColor = QColor(255, 219, 41) #orange
def changeRoomNumber(self, text):
self.roomNumber = int(text) + 1
def randomize(self):
self.width = r.randint(175, 275)
self.changeWidth.setValue(self.width - 175)
self.height = r.randint(100, 150)
self.changeHeight.setValue(self.height - 100)
self.roofHeight = r.randint(50, 100)
self.changeRoofHeight.setValue(self.roofHeight - 50)
self.mainColor1 = QColor(r.randint(0, 255), r.randint(0, 255),
r.randint(0, 255))
self.mainColor2 = QColor(r.randint(0, 255), r.randint(0, 255),
r.randint(0, 255))
self.roofColor = QColor(r.randint(0, 255), r.randint(0, 255),
r.randint(0, 255))
self.doorColor = QColor(r.randint(0, 255), r.randint(0, 255),
r.randint(0, 255))
def paintEvent(self, event):
super().paintEvent(event)
rect = QRect(self.x0, self.y0, abs(self.x1 - self.x0), abs(self.y1 - self.y0))
painter = QPainter(self)
painter.setPen(QPen(Qt.red, 1, Qt.SolidLine))
painter.drawRect(rect)
def draw(self):
logger.debug('draw')
painter = QPainter(self.pix)
# pen = QPen(Qt.black, 1, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin)
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setPen(self.pen)
painter.begin(self.pix)
self.drawPath(painter)
painter.end()
self.update()
def paintEvent(self, event):
qp = QPainter()
qp.begin(self)
self.drawText(event, qp)
qp.end()
def init_parameters(self):
'''
初始化系统参数,可读取系统配置文件
:return:
'''
self.count = 0
self.resolution = QDesktopWidget().availableGeometry(
) # 获取显示器的分辨率-->(0, 0, 1366, 728)
self.monitor = QDesktopWidget() # 获得显示器的物理尺寸
# self.setWindowFlags(Qt.Tool | Qt.X11BypassWindowManagerHint) # 任务栏隐藏图标
# 会议号
self.meetingID = 0 # 当前会议号
# 页数记录
self.page = 1 # 当前所在页页码
self.pages = 1 # 总页数
self.isWritting = False # 是否正在输入
self.isWritten = False # 记录当前页是否有新写入
##########2018-6-12 添加###########
self.httpRequest = HttpRequest() # http请求对象那
self.is_login = True # 用户是否登录
# self.shareThread = threading.Thread(target=self.meetingConnection, daemon=True) # 创建一个实时分享的线程
# self.shareThread.start()
# 多线程改为多进程
self.shareThread = threading.Thread(target=self.self_check_net,
daemon=True) # 创建一个实时分享的线程
self.shareThread.start()
# print('# 创建一个实时分享的进程1')
# self.shareProcess = multiprocessing.Process(target=self.self_check_net) # 创建一个实时分享的进程
# self.shareProcess.start()
# print('# 创建一个实时分享的进程2')
self.screenshotFullScreen = ScreenShotsWin() # 用于截全屏的对象
##########2018-6-12 添加###########
# 记录笔迹（坐标，颜色）
self.penColor = 0 # 笔的初始颜色黑色
self.pos_xyc = [] # [((x, y), c)] c->0 1 2 3
self.pos_pages = {} # 存放所有页笔画路径{page : pos_xyc}
# 设置不追踪鼠标
self.setMouseTracking(False)
# 使用指定的画笔，宽度，钢笔样式，帽子样式和连接样式构造笔
self.pen = QPen(Qt.black, 4, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin)
# 画布pix
self.pix = QPixmap(self.resolution.size())
self.pix.fill(Qt.white)
self.pix = QPixmap(self.resolution.size())
self.pix.fill(Qt.white)
# self.pix.save('原图.png')
# 黑板擦
'''
改用 eraseRect ，直接去掉笔画
void QPainter::eraseRect(const QRectF &rectangle)
Erases the area inside the given rectangle. Equivalent to calling
fillRect(rectangle, background()).
'''
self.paintEase = QPainter(self)
self.paintEase.setPen(QPen(Qt.black, Qt.DashLine))
self.paintEase.setBrush(QBrush(Qt.red, Qt.SolidPattern))
# 是否擦除
self.eraseable = False
# 起点终点
self.lastPoint = QPoint()
self.endPoint = QPoint()
self.icon = QIcon("icon\Icon.png") # 窗体图标
self.addSystemTray() # 设置系统托盘
def paintEvent(self, e):
#print("paint")
self.qp = QPainter(self)
#self.qp.setPen(QColor(245, 245, 245)) #if you need no black circuit
triangle = QPolygonF([
QPointF(200, 200),
QPointF(200 + self.width, 200),
QPointF(200 + self.width / 2, 200 - self.roofHeight)
])
self.qp.setBrush(QBrush(self.roofColor, Qt.SolidPattern))
self.qp.drawPolygon(triangle) #roof
self.qp.setBrush(QBrush(self.mainColor1, Qt.SolidPattern))
self.qp.drawRect(200, 200, self.width, self.height) #upper part
self.qp.setBrush(QBrush(self.mainColor2, Qt.SolidPattern))
self.qp.drawRect(200, 200 + self.height, self.width,
self.height) #lower part
#details
self.qp.setBrush(QBrush(self.doorColor, Qt.SolidPattern))
self.qp.drawRect(130 + self.width, 115 + 2 * self.height, 50,
80) #calculate door
self.qp.setBrush(QBrush(self.lightColor, Qt.SolidPattern))
self.qp.drawRect(140 + self.width, 125 + 2 * self.height, 30,
40) #window on the door
self.qp.setBrush(QBrush(QColor(173, 98, 23), Qt.SolidPattern))
self.qp.drawEllipse(173 + self.width, 160 + 2 * self.height, 4,
4) #door handle
#variants of the window on the third floor
self.qp.setBrush(QBrush(self.lightColor, Qt.SolidPattern))
if self.windowStyle == "Round window":
diameter = 30 * (self.roofHeight / 50) #calculate proportion
if diameter > 45:
diameter = 45 #limit for normal design
self.qp.drawEllipse(200 - diameter / 2 + self.width / 2,
200 - diameter / 2 - self.roofHeight * 0.45,
diameter, diameter)
self.qp.setPen(QPen(QColor(173, 98, 23), 3,
Qt.SolidLine)) #window planks
self.qp.drawLine(202 - diameter / 2 + self.width / 2,
200 - self.roofHeight * 0.45,
198 + diameter / 2 + self.width / 2,
200 - self.roofHeight * 0.45)
self.qp.drawLine(200 + self.width / 2,
198 + diameter / 2 - self.roofHeight * 0.45,
200 + self.width / 2,
202 - diameter / 2 - self.roofHeight * 0.45)
if self.windowStyle == "2-part window":
left = QPolygonF([
QPointF(200 + self.width / 3, 195),
QPointF(197 + self.width / 2, 195),
QPointF(197 + self.width / 2, 210 - self.roofHeight / 1.04),
QPointF(200 + self.width / 3, 210 - self.roofHeight / 1.5)
])
self.qp.drawPolygon(left)
right = QPolygonF([
QPointF(200 + self.width * 2 / 3, 195),
QPointF(203 + self.width / 2, 195),
QPointF(203 + self.width / 2, 210 - self.roofHeight / 1.04),
QPointF(200 + self.width * 2 / 3, 210 - self.roofHeight / 1.5)
])
self.qp.drawPolygon(right)
#window on the first floor
self.qp.setPen(QPen(Qt.black, 1, Qt.SolidLine))
self.qp.drawRect(210 + 2 / 5 * (self.width - 175),
110 + 2 * self.height - 1 / 5 * (self.height - 100),
75 + 2 / 5 * (self.width - 175),
65 + 1 / 5 * (self.height - 100))
xc = 210 + 2 / 5 * (self.width - 175) + (75 + 2 / 5 *
(self.width - 175)) / 2
yc = 110 + 2 * self.height - 1 / 5 * (self.height -
100) + (65 + 1 / 5 *
(self.height - 100)) / 2
xr = 208 + 2 / 5 * (self.width - 175) + 75 + 2 / 5 * (self.width - 175)
yd = 108 + 2 * self.height - 1 / 5 * (
self.height - 100) + 65 + 1 / 5 * (self.height - 100)
self.qp.setPen(QPen(QColor(173, 98, 23), 3, Qt.SolidLine))
self.qp.drawLine(212 + 2 / 5 * (self.width - 175), yc, xr, yc)
self.qp.drawLine(xc,
112 + 2 * self.height - 1 / 5 * (self.height - 100),
xc, yd)
#windows on the second floor
self.qp.setPen(QPen(Qt.black, 1, Qt.SolidLine))
yc = 110 + self.height - 1 / 5 * (self.height - 100)
yd = 65 + 1 / 5 * (
self.height - 100
) #use our previous variables to make arguments shorter
if self.roomNumber == 1:
self.qp.drawRect(200 + self.width * 0.2, yc, self.width * 0.6, yd)
self.qp.setPen(QPen(QColor(173, 98, 23), 3, Qt.SolidLine))
self.qp.drawLine(200 + self.width * 0.4, yc + 2,
200 + self.width * 0.4, yc + yd - 2)
self.qp.drawLine(200 + self.width * 0.6, yc + 2,
200 + self.width * 0.6, yc + yd - 2)
if self.roomNumber == 2:
self.qp.drawRect(200 + self.width * 0.1, yc, self.width * 0.35, yd)
self.qp.drawRect(200 + self.width * 0.55, yc, self.width * 0.35,
yd)
self.qp.setPen(QPen(QColor(173, 98, 23), 3, Qt.SolidLine))
self.qp.drawLine(200 + self.width * 0.275, yc + 2,
200 + self.width * 0.275, yc + yd - 2)
self.qp.drawLine(200 + self.width * 0.725, yc + 2,
200 + self.width * 0.725, yc + yd - 2)
self.qp.end()
self.update() #need to draw again our image
def drawPixmapForPartiallyChecked(self, painter: QPainter, width: int,
height: int) -> None:
painter.setRenderHint(QPainter.Antialiasing)
pen = QPen()
pen.setWidth(2)
painter.setPen(pen)
painter.drawRect(QRect(5, 5, width - 10, height - 10))
pen.setWidth(4)
pen.setColor(QColor(139, 137, 137))
painter.setPen(pen)
painter.drawLine(width / 2 - 5, height / 2, width / 2, height - 10)
painter.drawLine(width / 2, height - 10, width / 2 + 10, 2)
painter.end()
class DrawingBoardUIBusi(QMainWindow):
# 单例模式
# _instance = None
#
# def __new__(cls, *args, **kw):
# if not cls._instance:
# cls._instance = super(DrawingBoardUIBusi, cls).__new__(cls, *args, **kw)
# return cls._instance
def __init__(self, meetingId=None, meetingNumber=None):
super(DrawingBoardUIBusi, self).__init__()
self.meetingNumber = meetingNumber # 会议编号
self.meetingId = meetingId # 会议号
self.init_parameters() # 初始化系统参数
self.setupUi() # 创建UI
self.setWindowOpacity(1) # 设置透明度
self.init_serial_port() # 初始化串口通信
def init_serial_port(self):
# 初始化串口通信，接收命令
self.serial = SerialHandler()
if self.serial.ser.port != None:
self.serial.port_open()
self.t1 = threading.Thread(target=self.receive_data, daemon=True)
# 多线程改为多进程
# self.t1 = multiprocessing.Process(target=self.receive_data)
# self.t1.setDaemon(True)
self.t1.start()
print('串口通信多进程开启')
def receive_data(self):
# 一直接收串口命令，执行相应的指令
print("The receive_data threading is start")
res_data = ''
num = 0
while (self.serial.ser.isOpen()):
time.sleep(1) # 查询不那么频繁
size = self.serial.ser.inWaiting() # 获取输入缓冲区中的字节数
if size:
res_data = self.serial.ser.read_all()
res_data_new = binascii.b2a_hex(res_data).decode()
print('接收到的数据：%s' % (res_data_new))
print(res_data_new.find('01'))
if res_data_new[4:6] == '01':
# 按键1--清屏
self.clearScree()
elif res_data_new[4:6] == '02':
# 按键2--保存
self.savePicture(True)
elif res_data_new[4:6] == '03':
# 按键3--上一页
print('上一页')
self.previousPage()
elif res_data_new[4:6] == '04':
# 按键4--下一页
print('下一页')
self.nextPage()
elif res_data_new[4:6] == '05':
# 按键5--黑笔
self.changeColor(0)
elif res_data_new[4:6] == '06':
# 按键6--蓝笔
self.changeColor(1)
elif res_data_new[4:6] == '07':
# 按键7--红笔
self.changeColor(2)
elif res_data_new[4:6] == '08':
# 按键8--擦除
self.erase()
# binascii.b2a_hex(res_data).decode()
self.serial.ser.flushInput() # 刷新输入缓冲区
num += 1
print("接收：" + str(num))
def setupUi(self):
'''
创建UI,
:return:
'''
self.setObjectName('drawWindow') # 对象名
self.setWindowTitle('白板') # 设置标题
self.resize(self.resolution.width(), self.resolution.height())
self.setWindowIcon(QIcon("qrc\Icon.png")) # 设置图标
self.setWindowFlags(Qt.Tool | Qt.X11BypassWindowManagerHint) # 任务栏隐藏图标
# self.setWindowTitle('当前' + str(self.page) + '页') # 标题显示第几页
self.setWindowTitle('当前' + '页') # 标题显示第几页
# self.setWindowFlags(
# Qt.CustomizeWindowHint | Qt.WindowStaysOnTopHint | Qt.WindowTitleHint | Qt.WindowMinimizeButtonHint | Qt.WindowCloseButtonHint)
self.setWindowFlags(Qt.FramelessWindowHint | Qt.WindowStaysOnTopHint)
self.setFixedSize(self.width(), self.height()) # 设置主窗口禁止调整大小
# 创建白板的功能键
btn_names = [
'清屏', '保存', '切换', '上一页', '下一页', '黑笔', '蓝笔', '红笔', '擦除', '功能', '恢复',
'加载'
]
# 各个按钮的位置
positions = [(self.resolution.width() -
self.resolution.height() / len(btn_names),
(y * self.resolution.height() / len(btn_names)))
for y in range(0, len(btn_names))]
# 每个功能按钮的高度
height = (self.resolution.height() / len(btn_names)) * 0.98
'''要重构这部分代码'''
# 清屏
self.btn_clean = QPushButton(btn_names[0], self)
self.btn_clean.resize(height, height)
self.btn_clean.move(positions[0][0], positions[0][1])
self.btn_clean.clicked.connect(self.clearScree)
self.btn_clean.setVisible(False)
# self.btn_clean.setStyleSheet("background-color: rgba(0,125,0,0)")
# 保存
self.btn_savePicture = QPushButton(btn_names[1], self)
self.btn_savePicture.resize(height, height)
self.btn_savePicture.move(positions[1][0], positions[1][1])
self.btn_savePicture.clicked.connect(lambda: self.savePicture(False))
self.btn_savePicture.setVisible(False)
# 切换
self.btn_switch = QPushButton(btn_names[2], self)
self.btn_switch.resize(height, height)
self.btn_switch.move(positions[2][0], positions[2][1])
self.btn_switch.clicked.connect(self.switch)
self.btn_switch.setVisible(False)
# 上一页
self.btn_previousPage = QPushButton(btn_names[3], self)
self.btn_previousPage.resize(height, height)
self.btn_previousPage.move(positions[3][0], positions[3][1])
self.btn_previousPage.clicked.connect(self.previousPage)
self.btn_previousPage.setVisible(False)
# 下一页
self.btn_nextPage = QPushButton(btn_names[4], self)
self.btn_nextPage.resize(height, height)
self.btn_nextPage.move(positions[4][0], positions[4][1])
self.btn_nextPage.clicked.connect(self.nextPage)
self.btn_nextPage.setVisible(False)
# 黑笔
self.btn_changeColor1 = QPushButton(btn_names[5], self)
self.btn_changeColor1.resize(height, height)
self.btn_changeColor1.move(positions[5][0], positions[5][1])
self.btn_changeColor1.clicked.connect(lambda: self.changeColor(0))
self.btn_changeColor1.setEnabled(True)
self.btn_changeColor1.setVisible(False)
# 蓝笔
self.btn_changeColor2 = QPushButton(btn_names[6], self)
self.btn_changeColor2.resize(height, height)
self.btn_changeColor2.move(positions[6][0], positions[6][1])
self.btn_changeColor2.clicked.connect(lambda: self.changeColor(1))
self.btn_changeColor2.setEnabled(True)
self.btn_changeColor2.setVisible(False)
# 红笔
self.btn_changeColor3 = QPushButton(btn_names[7], self)
self.btn_changeColor3.resize(height, height)
self.btn_changeColor3.move(positions[7][0], positions[7][1])
self.btn_changeColor3.clicked.connect(lambda: self.changeColor(2))
self.btn_changeColor3.setEnabled(True)
self.btn_changeColor3.setVisible(False)
# 擦除
self.btn_erase = QPushButton(btn_names[8], self)
self.btn_erase.resize(height, height)
self.btn_erase.move(positions[8][0], positions[8][1])
self.btn_erase.clicked.connect(self.erase)
self.btn_erase.setVisible(False)
'''
# 功能
self.btn_startSharing = QPushButton(btn_names[9], self)
self.btn_startSharing.resize(height, height)
self.btn_startSharing.move(positions[9][0], positions[9][1])
self.btn_startSharing.clicked.connect(self.startSharing)
# 恢复
self.btn_restorePicture = QPushButton(btn_names[10], self)
self.btn_restorePicture.resize(height, height)
self.btn_restorePicture.move(positions[10][0], positions[10][1])
self.btn_restorePicture.clicked.connect(self.restorePicture)
# 加载
self.btn_loadPicture = QPushButton(btn_names[11], self)
self.btn_loadPicture.resize(height, height)
self.btn_loadPicture.move(positions[11][0], positions[11][1])
self.btn_loadPicture.clicked.connect(self.loadPicture)
'''
def init_parameters(self):
'''
初始化系统参数,可读取系统配置文件
:return:
'''
self.count = 0
self.resolution = QDesktopWidget().availableGeometry(
) # 获取显示器的分辨率-->(0, 0, 1366, 728)
self.monitor = QDesktopWidget() # 获得显示器的物理尺寸
# self.setWindowFlags(Qt.Tool | Qt.X11BypassWindowManagerHint) # 任务栏隐藏图标
# 会议号
self.meetingID = 0 # 当前会议号
# 页数记录
self.page = 1 # 当前所在页页码
self.pages = 1 # 总页数
self.isWritting = False # 是否正在输入
self.isWritten = False # 记录当前页是否有新写入
##########2018-6-12 添加###########
self.httpRequest = HttpRequest() # http请求对象那
self.is_login = True # 用户是否登录
# self.shareThread = threading.Thread(target=self.meetingConnection, daemon=True) # 创建一个实时分享的线程
# self.shareThread.start()
# 多线程改为多进程
self.shareThread = threading.Thread(target=self.self_check_net,
daemon=True) # 创建一个实时分享的线程
self.shareThread.start()
# print('# 创建一个实时分享的进程1')
# self.shareProcess = multiprocessing.Process(target=self.self_check_net) # 创建一个实时分享的进程
# self.shareProcess.start()
# print('# 创建一个实时分享的进程2')
self.screenshotFullScreen = ScreenShotsWin() # 用于截全屏的对象
##########2018-6-12 添加###########
# 记录笔迹（坐标，颜色）
self.penColor = 0 # 笔的初始颜色黑色
self.pos_xyc = [] # [((x, y), c)] c->0 1 2 3
self.pos_pages = {} # 存放所有页笔画路径{page : pos_xyc}
# 设置不追踪鼠标
self.setMouseTracking(False)
# 使用指定的画笔，宽度，钢笔样式，帽子样式和连接样式构造笔
self.pen = QPen(Qt.black, 4, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin)
# 画布pix
self.pix = QPixmap(self.resolution.size())
self.pix.fill(Qt.white)
self.pix = QPixmap(self.resolution.size())
self.pix.fill(Qt.white)
# self.pix.save('原图.png')
# 黑板擦
'''
改用 eraseRect ，直接去掉笔画
void QPainter::eraseRect(const QRectF &rectangle)
Erases the area inside the given rectangle. Equivalent to calling
fillRect(rectangle, background()).
'''
self.paintEase = QPainter(self)
self.paintEase.setPen(QPen(Qt.black, Qt.DashLine))
self.paintEase.setBrush(QBrush(Qt.red, Qt.SolidPattern))
# 是否擦除
self.eraseable = False
# 起点终点
self.lastPoint = QPoint()
self.endPoint = QPoint()
self.icon = QIcon("icon\Icon.png") # 窗体图标
self.addSystemTray() # 设置系统托盘
def addSystemTray(self):
'''
系统托盘，显示、隐藏主窗体，退出程序
:return:
'''
minimizeAction = QAction("隐藏", self, triggered=self.hide) # 隐藏菜单
maximizeAction = QAction("显示", self, triggered=self.show) # 显示菜单
restoreAction = QAction("恢复", self, triggered=self.showNormal) # 恢复菜单
quitAction = QAction("退出", self, triggered=self.close) # 退出菜单
self.trayIconMenu = QMenu(self)
self.trayIconMenu.addAction(minimizeAction)
self.trayIconMenu.addAction(maximizeAction)
self.trayIconMenu.addAction(restoreAction)
self.trayIconMenu.addSeparator()
self.trayIconMenu.addAction(quitAction)
self.trayIcon = QSystemTrayIcon(self)
self.trayIcon.setIcon(self.icon) # 设置系统托盘图标
self.setWindowIcon(self.icon) # 设置系统窗体图标
self.trayIcon.setContextMenu(self.trayIconMenu) # 添加右键菜单
self.trayIcon.activated.connect(self.trayClick) # 左键点击托盘
self.trayIcon.show()
def trayClick(self, event):
'''
双击系统托盘显示主窗体
:param event:
:return:
'''
if event == QSystemTrayIcon.DoubleClick: # 双击
self.showNormal()
else:
pass
def applyForMeetingNum(self):
'''
申请会议号
:return:
'''
response = self.httpRequest.applyForMeetingNum()
# result = json.loads(response.content)
try:
result = response.json()['data']
print(type(result))
logger.debug(result)
self.meetingId, self.meetingNumber = result.split('&') # 截取会议编号
logger.debug(self.meetingId)
logger.debug(self.meetingNumber)
QMessageBox.information(self, '申请会议号成功',
'会议号：' + self.meetingNumber,
QMessageBox.Ok)
except:
logger.debug('网络衔接失败')
QMessageBox.warning(self, '警告', '网络连接失败！请检查网络设备！',
QMessageBox.Cancel)
def meetingConnection(self):
logger.debug('查询用户请求')
while (True):
if self.is_login and is_share:
time.sleep(2) # 等待1s
logger.debug('分享开启')
try:
response = self.httpRequest.meetingConnection(
self.meetingId)
result = response.json()
code = result['code']
print(result, code)
if code == '0':
# 需再次建立会议连接
print('需再次建立会议连接')
time.sleep(2) # 等待1s
continue
elif code == '1':
# 有用户需要截屏
print('有用户需要截屏')
t_upload = threading.Thread(target=self.uploadPic,
daemon=True)
t_upload.start()
t_upload.join()
time.sleep(5) # 等待1s
elif code == '-1':
# 请求过于频繁，当前已有连接处于等待状态
print('请求过于频繁，当前已有连接处于等待状态')
time.sleep(5) # 等待1s
continue
else:
print('“会议不存在，请重新分配会议号”')
except:
logger.debug('网络衔接失败')
else:
# logger.debug('分享关闭')
pass
def self_check_net(self):
print('分享线程开始')
while (True):
print('循環')
flag = self.count == 0
time.sleep(2)
if flag:
if self.count == 0:
self.weather_con()
def weather_con(self):
print('+++++ 查询服务器请求 ++++++')
if self.is_login and is_share and self.count <= 2:
self.count += 1
response = self.httpRequest.meetingConnection(self.meetingId)
print('response: %s' % response)
if response != None:
result = response.json()
print(result)
code = result['code']
self.count -= 1
print('result:', result)
if code == '0':
print('code: 0')
self.weather_con()
elif code == '1':
print('code: 1')
# t_upload = threading.Thread(target=self.uploadPic, daemon=True)
# t_upload.start()
print('截图多进程1')
p_upload = multiprocessing.Process(target=self.uploadPic)
p_upload.start()
print('截图多进程1')
# self.weather_con()
elif code == '-1':
print('code: -1')
pass
elif code == '-2':
print('code: -2')
self.applyForMeetingNum()
def uploadPic(self):
self.screenshotsFullScreen() # 截图
fileName = 'save/temp/' + str(self.page) + '.jpg'
files = {'file': open(fileName, 'rb')}
print('开始上传图片')
respone = self.httpRequest.uploadPic(files=files,
meetingId=self.meetingId,
pageNum=self.page)
print('上传图片成功')
print(respone)
def screenshotsFullScreen(self):
'''
截图全图
:return:全屏的截图pix.png
'''
pix = self.screenshotFullScreen.screenshotsFullScreen()
fileName = 'save/temp/' + str(self.page) + '.jpg'
pix.save(fileName)
print('截图并保存成功')
def paintEvent(self, event):
'''绘图事件'''
# 绘制在屏幕上
painter_to_window = QPainter(self)
painter_to_window.setRenderHint(QPainter.Antialiasing, True) # 反锯齿
painter_to_window.setRenderHint(QPainter.SmoothPixmapTransform, True)
painter_to_window.drawPixmap(0, 0, self.pix)
def mousePressEvent(self, event):
# 鼠标左键按下
if event.button() == Qt.LeftButton:
self.isWritten = True # 当前页有输入或改动
self.isWritting = True # 已开始抒写
self.lastPoint = event.pos()
self.endPoint = self.lastPoint
logger.debug('点击左键')
g_hw_render.insert_first(event.pos().x(), event.pos().y())
def mouseMoveEvent(self, event):
'''
调用update()函数在这里相当于调用paintEvent()函数
'''
if event.buttons() and Qt.LeftButton:
self.endPoint = event.pos()
# 进行重新绘制
logger.debug('鼠标移动')
g_hw_render.insert(event.pos().x(), event.pos().y())
self.draw() # 绘制
self.update()
def mouseReleaseEvent(self, event):
# 鼠标左键释放
if event.button() == Qt.LeftButton:
self.endPoint = event.pos()
# 进行重新绘制
g_hw_render.insert_last(event.pos().x(), event.pos().y())
self.draw() # 绘制
self.update()
self.isWritting = False # 已停止抒写
logger.debug('左键释放')
def draw(self):
logger.debug('draw')
painter = QPainter(self.pix)
# pen = QPen(Qt.black, 1, Qt.SolidLine, Qt.RoundCap, Qt.RoundJoin)
painter.setRenderHint(QPainter.SmoothPixmapTransform, True)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setPen(self.pen)
painter.begin(self.pix)
self.drawPath(painter)
painter.end()
self.update()
def drawPath(self, painter):
m_cur_path = g_hw_render.get_m_cur_path()
start_index = 0
if m_cur_path.len > 11:
start_index = m_cur_path.len - 11
else:
start_index = 0
for p in range(start_index, m_cur_path.len - 1):
# print(i)
# print("输出所有点和宽度(%d,%d)_%f" % (m_cur_path._point[p].p.x, m_cur_path._point[p].p.y, m_cur_path._point[p].w))
point1 = QPoint(m_cur_path._point[p].p.x, m_cur_path._point[p].p.y)
point2 = QPoint(m_cur_path._point[p + 1].p.x,
m_cur_path._point[p + 1].p.y)
w = m_cur_path._point[p].w
if self.eraseable == True:
self.pen.setWidth(100) # 设置黑板擦宽度
else:
# 改变笔的粗细
self.pen.setWidthF(w * 25)
pass
painter.setPen(self.pen)
painter.drawLine(point1, point2)
logger.debug('drawPath')
def keyPressEvent(self, event):
'''
键盘事件
:param event:
:return:
'''
key = event.key()
# ESC最小化白板
if key == Qt.Key_Escape:
self.hide()
elif key == Qt.Key_A and event.modifiers() == Qt.ControlModifier:
self.applyForMeetingNum() # 申请会议号
elif key == Qt.Key_F5:
# 开启分享
global is_share
if not is_share:
is_share = True
self.setWindowTitle("白板 - 分享已开启@" + self.meetingNumber)
elif is_share and self.shareThread.is_alive():
is_share = False
self.setWindowTitle("白板 - 分享已关闭")
def contextMenuEvent(self, event):
'''
白板中的右键菜单
:param event:
:return:
'''
qmenu = QMenu(self)
qmenu.addAction('清屏', self.clearScree)
savePictureAct = qmenu.addAction('保存')
savePictureAct.triggered.connect(lambda: self.savePicture(False))
qmenu.addAction('切换', self.switch)
qmenu.addSeparator()
qmenu.addAction('上一页', self.previousPage)
qmenu.addAction('下一页', self.nextPage)
qmenu.addSeparator()
self.changeColorBlack = qmenu.addAction('黑笔')
self.changeColorBlack.triggered.connect(lambda: self.changeColor(0))
self.changeColorBlue = qmenu.addAction('蓝笔')
self.changeColorBlue.triggered.connect(lambda: self.changeColor(1))
self.changeColorRed = qmenu.addAction('红笔')
self.changeColorRed.triggered.connect(lambda: self.changeColor(2))
qmenu.addAction('擦除', self.erase)
qmenu.addSeparator()
# self.changeThickness = qmenu.addAction('笔的粗细', self.changeThickness())
# qmenu.addSeparator()
# qmenu.addAction('功能', self.startSharing)
# qmenu.addAction('恢复', self.restorePicture)
# qmenu.addAction('加载', self.loadPicture)
self.action = qmenu.exec_(self.mapToGlobal(event.pos()))
def loadPicture(self):
# 加载本地图片
pass
def restorePicture(self):
pass
def startSharing(self):
pass
def changeThickness(self):
pass
def erase(self):
if self.eraseable == False:
self.eraseable = True
self.pen.setColor(Qt.white) # 设置黑板擦的颜色为白色，与画板颜色一致
self.pen.setWidth(100) # 设置黑板擦宽度
# self.paint_to_pix.setPen(self.pen) # 更新paint_to_pix
self.penColor = 3
else:
self.eraseable = False
self.changeColor(0)
def changeColor(self, colorNum):
'''
换颜色
:param colorNum: 颜色号
:return:
'''
# 关闭黑板擦
self.eraseable = False
# 笔的颜色
colorDic = {0: Qt.black, 1: Qt.blue, 2: Qt.red}
self.pen.setColor(colorDic[colorNum])
self.penColor = colorNum
# self.pen.setWidth(4) # 设置固定宽度
def nextPage(self):
'''
切换下一页画布
:return:
'''
print('下一页1')
if self.isWritten:
# 当前页有输入或改动则保存当前页
self.savePicture(True)
# self.pos_pages[self.page] = self.pos_xyc # 记录当前页笔画路径
self.isWritten = False # 关闭改动标志
print('下一页2')
if self.page == self.pages:
# 开辟新一页，总页数加一
# self.pos_xyc = [] # 当前页路径清空
self.pages += 1 # 页总数加一
self.pix.fill(Qt.white) # 清空画布
else:
# 当前页并非最后一页
print('下一页3')
fileName = str(self.page + 1)
readFileName = os.path.join(self.filePath, 'temp',
fileName + '.jpg')
QPixmapCache.clear()
self.pix.load(readFileName)
# self.pos_xyc = self.pos_pages[self.page + 1]
print('下一页4')
self.update() # 更新内容
print('下一页5')
self.page = self.page + 1 # 当前页码加一
print('下一页6')
# t_changName = threading.Thread(target=self.changeWinName, args=(self.page, self.pages,))
# t_changName.start()
# self.setWindowTitle('当前' + str(self.page) + '/' + str(self.pages) + '页') # 更新标题栏显示的页码
print('下一页7')
logger.debug('下翻页第%s页', self.page)
def changeWinName(self, page, pages):
self.setWindowTitle('当前' + str(page) + '/' + str(page) +
'页') # 更新标题栏显示的页码
def previousPage(self):
'''
切换到上一页画布
:return:
'''
if self.isWritten or (self.page == self.pages):
# 当前页有输入或改动则保存当前页
self.savePicture(True)
# self.pos_pages[self.page] = self.pos_xyc # 记录当前页笔画路径
self.isWritten = False # 关闭改动标志
if self.page > 1:
# 当前页码非第一页
self.page -= 1 # 当前页码减一
fileName = str(self.page)
readFileName = os.path.join(self.filePath, 'temp',
fileName + '.jpg')
QPixmapCache.clear() # 清空画布
self.pix.load(readFileName)
# self.pos_xyc = self.pos_pages[self.page]
else:
# 当前页码为第一页
pass
self.update() # 更新内容
print('下一页6')
# self.setWindowTitle('当前' + str(self.page) + '/' + str(self.pages) + '页') # 更新标题栏显示的页码
# t_changName = threading.Thread(target=self.changeWinName, args=(self.page, self.pages,))
# t_changName.start()
logger.debug('上翻页第%s页', self.page)
def switch(self):
'''切换'''
self.showMinimized()
def savePicture(self, flag=True, meetingID='201711'):
'''
将当前白板上的内容保存成图片
flag = True,为自动保存
flag = False为用户保存
'''
# 保存目录 './save/日期+会议号/'
time = QDateTime.currentDateTime().toString("yyyy-MM-dd_")
self.meetingID = meetingID
self.filePath = os.path.join(os.getcwd(), 'save',
time + self.meetingID)
# 创建目录
if not os.path.exists(self.filePath):
os.makedirs(self.filePath)
os.makedirs(os.path.join(self.filePath, 'temp'))
if flag:
# 自动保存分为两部分：1.保存图片到本地 2.保存保存路径json文件到本地
# 1.保存图片到本地
# fileName = QDateTime.currentDateTime().toString('yyMMddhhmmss')
fileName = str(self.page) # 以页码为图片名
logger.debug(
'filePath %s',
os.path.join(self.filePath, 'temp', fileName + '.jpg'))
self.pix.save(
os.path.join(self.filePath, 'temp', fileName + '.jpg'))
logger.debug('保存图片')
# 2.保存保存路径json文件到本地
import json
dict = {
'pox_xyc': self.pos_xyc,
'page': self.page,
'meetingID': self.meetingID
}
# logger.debug('dict: %s', dict)
with open(os.path.join(self.filePath, 'temp', fileName + '.json'),
'w') as f:
json.dump(dict, f)
logger.debug('保存json文件')
else:
# 用户手动保存
fileName = QFileDialog.getSaveFileName(self, '保存图片', self.filePath,
".png;;.jpg")
self.pix.save(fileName[0] + fileName[1])
def clearScree(self):
'''清屏'''
# self.pos_xyc.clear()
self.update()
self.pix.fill(Qt.white)
def closeEvent(self, QCloseEvent):
'''
关闭白板时保存当前画板内容
:return:
'''
print('关闭白板')
qApp.quit() # 强制关闭
