class QMarkablePicture(QLabel): def __init__(self, parent=None): QLabel.__init__(self, parent) self.initBrush() self.marks = [] self.is_marks_count_limited = False self.marks_count_limit = 0 def initBrush(self): self.brush = QBrush(Qt.SolidPattern) self.brush.setColor(QColor(constants.defaultBrushColor)) def paintEvent(self, e): QLabel.paintEvent(self, e) painter = QPainter() painter.begin(self) painter.setBrush(self.brush) for mark in self.marks: painter.drawEllipse(mark, constants.ellipsWidth, constants.ellipsHeight) painter.end() def setBrushColor(self, color): self.brush.setColor(color) def drawMark(self, mark): if self.__isAbleDrawMark(): self.marks.append(mark) self.update() def removeMark(self, mark): for painted_mark in self.marks: if self.__isApproximatelyEqual(mark, painted_mark, constants.epsilon): self.marks.remove(painted_mark) break self.update() def getMarks(self): return self.marks.copy() def setMarksCountLimit(self, limit): self.is_marks_count_limited = True self.marks_count_limit = limit def __isAbleDrawMark(self): limit_enabled_condition = self.is_marks_count_limited and (len(self.marks) < self.marks_count_limit) limit_disabled_condition = not self.is_marks_count_limited return limit_enabled_condition or limit_disabled_condition def __isApproximatelyEqual(self, firstMark, secondMark, epsilon): full_equality = firstMark == secondMark x_top_limit = (firstMark.x() + epsilon) >= secondMark.x() x_bottom_limit = (firstMark.x() - epsilon) <= secondMark.x() x_equality = x_top_limit and x_bottom_limit y_top_limit = (firstMark.y() + epsilon) >= secondMark.y() y_bottom_limit = (firstMark.y() - epsilon) <= secondMark.y() y_equality = y_top_limit and y_bottom_limit return full_equality or (x_equality and y_equality)
def createArrow(self): # add an arrow to destination line myLine = self.destinationLine.line() myLine.setLength(myLine.length() - TransitionGraphicsItem.ARROW_SIZE) rotatePoint = myLine.p2() - self.destinationLine.line().p2() rightPointX = rotatePoint.x() * math.cos(math.pi / 6) - rotatePoint.y() * math.sin(math.pi / 6) rightPointY = rotatePoint.x() * math.sin(math.pi / 6) + rotatePoint.y() * math.cos(math.pi / 6) rightPoint = QPointF(rightPointX + self.destinationLine.line().x2(), rightPointY + self.destinationLine.line().y2()) leftPointX = rotatePoint.x() * math.cos(-math.pi / 6) - rotatePoint.y() * math.sin(-math.pi / 6) leftPointY = rotatePoint.x() * math.sin(-math.pi / 6) + rotatePoint.y() * math.cos(-math.pi / 6) leftPoint = QPointF(leftPointX + self.destinationLine.line().x2(), leftPointY + self.destinationLine.line().y2()) polygon = QPolygonF() polygon << rightPoint << leftPoint << self.destinationLine.line().p2() << rightPoint if self.arrow == None: self.arrow = QGraphicsPolygonItem(polygon, self) else: self.arrow.setPolygon(polygon) brush = QBrush(Qt.SolidPattern) brush.setColor(Qt.black) self.arrow.setBrush(brush)
def drawCircle(self, painter, centerX, centerY, color, size): pen = QPen(color, size) painter.setPen(pen) brush = QBrush(Qt.SolidPattern) brush.setColor(QColor(Qt.blue)) painter.setBrush(brush) painter.drawEllipse(centerX, centerY, 5, 5)
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()
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 __init__(self, parent = None, message = None, itemType = "log"): QListWidgetItem.__init__(self) self.itemType = itemType if (itemType == "log"): self.setText("--- " + str(message)) elif (itemType == "in"): self.setText("<<< " + str(message)) elif (itemType == "out"): self.setText(">>> " + str(message)) else: self.setText(str(message)) font = QFont() font.setFamily("Monospace") if (itemType == "in") or (itemType == "out"): font.setBold(True) font.setWeight(75) else: font.setBold(False) font.setWeight(50) self.setFont(font) brush = QBrush(QColor(0, 0, 0)) if (itemType == "in"): brush = QBrush(QColor(0, 0, 85)) elif (itemType == "out"): brush = QBrush(QColor(0, 85, 0)) brush.setStyle(Qt.NoBrush) self.setForeground(brush)
def setStyle(self, painter, fillColor, penColor, stroke): brush = QBrush() pen = QPen(penColor, stroke) brush.setColor(fillColor) brush.setStyle(Qt.SolidPattern) painter.setBrush(brush) painter.setPen(pen) painter.setRenderHint(QPainter.Antialiasing)
def setRequired(self, required): self.required = required brush = QBrush() if required: brush.setColor(QColor(255, 0, 0)) else: brush.setColor(QColor(0, 0, 0)) self.setForeground(0, brush)
def __set_brushAlpha(self, alpha: int): """ Args: alpha: Description """ brush = QBrush(self.item.brush()) color = QColor(brush.color()) color.setAlpha(alpha) self.item.setBrush(QBrush(color))
class ModCloseButton(QPushButton): def __init__(self,parent,wide,high,ppath=None): QPushButton.__init__(self,parent) self.parent=parent self.wide=wide self.high=high self.resize(self.wide,self.high) self.xdis=self.wide/10 #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) if ppath : self.path=ppath else : self.path=QPainterPath() self.path.moveTo(self.wide/2, self.high/2-self.xdis) self.path.arcTo(0,0, self.wide-2*self.xdis, self.high-2*self.xdis,45,90) self.path.closeSubpath() self.path.moveTo(self.wide/2-self.xdis, self.high/2) self.path.arcTo(0,0,self.wide-2*self.xdis,self.high-2*self.xdis,135,90) self.path.closeSubpath() self.path.moveTo(self.wide/2, self.high/2+self.xdis) self.path.arcTo(0,0,self.wide-2*self.xdis, self.high-2*self.xdis,225,90) self.path.closeSubpath() self.path.moveTo(self.wide/2+self.xdis, self.high/2) self.path.arcTo(0,0,self.wide-2*self.xdis, self.high-2*self.xdis,315,90) self.path.closeSubpath() def paintEvent(self,event): 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(234,39,13) self.update() def leaveEvent(self,ev): self.backgroundColor.setRgb(157,157,157) self.update()
def valueChanged(self, property, value): if (not self.propertyToId.contains(property)): return if (not self.currentItem or self.currentItem.isNone()): return tp = type(value) id = self.propertyToId[property] if tp == float: if (id == "xpos"): self.currentItem.setX(value) elif (id == "ypos"): self.currentItem.setY(value) elif (id == "zpos"): self.currentItem.setZ(value) elif tp == str: if (id == "text"): if (self.currentItem.rtti() == RttiValues.Rtti_Text): i = self.currentItem i.setText(value) elif tp == QColor: if (id == "color"): if (self.currentItem.rtti() == RttiValues.Rtti_Text): i = self.currentItem i.setColor(value) elif (id == "brush"): if (self.currentItem.rtti() == RttiValues.Rtti_Rectangle or self.currentItem.rtti() == RttiValues.Rtti_Ellipse): i = self.currentItem b = QBrush(i.brush()) b.setColor(value) i.setBrush(b) elif (id == "pen"): if (self.currentItem.rtti() == RttiValues.Rtti_Rectangle or self.currentItem.rtti() == RttiValues.Rtti_Line): i = self.currentItem p = QPen(i.pen()) p.setColor(value) i.setPen(p) elif tp == QFont: if (id == "font"): if (self.currentItem.rtti() == RttiValues.Rtti_Text): i = self.currentItem i.setFont(value) elif tp == QPoint: if (self.currentItem.rtti() == RttiValues.Rtti_Line): i = self.currentItem if (id == "endpoint"): i.setPoints(i.startPoint().x(), i.startPoint().y(), value.x(), value.y()) elif tp == QSize: if (id == "size"): if (self.currentItem.rtti() == RttiValues.Rtti_Rectangle): i = self.currentItem i.setSize(value.width(), value.height()) elif (self.currentItem.rtti() == RttiValues.Rtti_Ellipse): i = self.currentItem i.setSize(value.width(), value.height()) self.canvas.update()
def paintEvent(self, ev): pen = QPen() pen.setStyle(Qt.DotLine) pen.setWidth(2) pen.setColor(QColor(Qt.white)) brush = QBrush() brush.setStyle(Qt.SolidPattern) brush.setColor(QColor(0, 0, 0)) painter = QPainter(self) painter.setPen(pen) painter.setBrush(brush) painter.drawRect(ev.rect())
def __set_brushAlpha(self, alpha): """Summary Args: alpha (TYPE): Description Returns: TYPE: Description """ brush = QBrush(self.item.brush()) color = QColor(brush.color()) color.setAlpha(alpha) self.item.setBrush(QBrush(color))
def drawShape(self, event, qp): pen = QPen(Qt.yellow) pen.setWidth(3) # rellenar fondo con patron de imagen brush = QBrush() brush.setTexture(QPixmap('image/small_image.jpg')) # establecer el QBrush qp.setBrush(brush) qp.setPen(pen) qp.drawRoundedRect(QRect(50, 50, 200, 150), 15, 15) # utilizar un patron predefinido brush.setStyle(Qt.DiagCrossPattern) qp.setBrush(brush) qp.drawEllipse(350, 50, 150, 150)
class WLLineLabel(QPushButton): def __init__(self,parent): super(WLLineLabel,self).__init__(parent) self.setWindowFlags(Qt.FramelessWindowHint ) self.linelength=1000 self.lineheight=5 self.resize(self.linelength, self.lineheight) self.move(100,100) self.stats=None #self.setStyleSheet("{background-color:transparent;border:none;color:transparent;}") self.backgroundColor = QPalette().light().color() self.backgroundColor.setRgb(157,157,157)#(220,203,231) #self.backgroundColor.setAlpha(255) self.brush=QBrush(Qt.SolidPattern) def paintEvent(self,event): self.brush.setColor(self.backgroundColor) self.painter=QPainter(self) self.painter.setRenderHint(QPainter.Antialiasing) self.painter.setPen(Qt.NoPen) self.painter.setBrush(self.brush) #print(self.geometry()) self.painter.drawRect(0, 0, 1000, 5) self.painter.end() def statsReset(self): self.stats=None self.backgroundColor.setAlpha(255) self.redraw() def mousePressEvent(self,ev): if self.stats == 'selected' : self.stats = None self.backgroundColor.setAlpha(255) else: self.stats = 'selected' self.backgroundColor.setRgb(157,157,157) self.update() def enterEvent(self,ev): #print('enter') if self.stats != 'selected' : self.backgroundColor.setAlpha(0) self.update() def leaveEvent(self,ev): if self.stats != 'selected' : self.backgroundColor.setAlpha(255) self.update()
def __init__(self, dblock: DBlock): super(DBlockTreeItem, self).__init__(dblock, dblock.name) self.dblock = dblock self.setSelectable(False) self.setEditable(False) self.tool_tip = "DBlock: " + dblock.name if isinstance(dblock, DEvent): brush = QBrush() brush.setColor(Qt.magenta) self.tool_tip = "DEvent: " + dblock.name self.setForeground(brush) self.setSelectable(True)
def __init__(self,parent=None,text='FigLabelWidget'): super(FigLabelWidget,self).__init__(parent) self.parent=parent self.lx=5 self.text=text self.fid=0 self.stats=None self.linecolor=QPalette().light().color() self.linecolor.setRgb(157,157,157) self.backgroundColor = QPalette().light().color() self.backgroundColor.setRgb(187,187,187) self.brush=QBrush(Qt.SolidPattern) self.brush2=QBrush(Qt.SolidPattern) self.activeLabel()
def __init__(self,parent, text=''): QPushButton.__init__(self, parent) self.text=text self.backgroundColor = QPalette().light().color() self.backgroundColor.setRgb(157,157,157) #(220,203,231) #self.backgroundColor.setAlpha(0) self.brush=QBrush(Qt.SolidPattern)
def mousePressEvent(self, event): """Summary Args: event (QGraphicsSceneMouseEvent): Description Returns: TYPE: Description """ if event.pos().y() < 10: new_color = self.colordialog.getColor(self._shift_color) if new_color.isValid() and new_color.name() != self._shift_color.name(): self._shift_color = new_color self._shift_brush = QBrush(new_color) if new_color not in self._shift_colors: self._shift_colors.insert(self._shift_color_index, new_color) self.update() else: new_color = self.colordialog.getColor(self._color) if new_color.isValid() and new_color.name() != self._color.name(): self._color = new_color self._brush = QBrush(new_color) if new_color not in self._colors: self._colors.insert(self._color_index, new_color) self.update()
def __init__(self,parent,wide,high,ppath=None): QPushButton.__init__(self,parent) self.parent=parent self.wide=wide self.high=high self.resize(self.wide,self.high) self.xdis=self.wide/10 #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) if ppath : self.path=ppath else : self.path=QPainterPath() self.path.moveTo(self.wide/2, self.high/2-self.xdis) self.path.arcTo(0,0, self.wide-2*self.xdis, self.high-2*self.xdis,45,90) self.path.closeSubpath() self.path.moveTo(self.wide/2-self.xdis, self.high/2) self.path.arcTo(0,0,self.wide-2*self.xdis,self.high-2*self.xdis,135,90) self.path.closeSubpath() self.path.moveTo(self.wide/2, self.high/2+self.xdis) self.path.arcTo(0,0,self.wide-2*self.xdis, self.high-2*self.xdis,225,90) self.path.closeSubpath() self.path.moveTo(self.wide/2+self.xdis, self.high/2) self.path.arcTo(0,0,self.wide-2*self.xdis, self.high-2*self.xdis,315,90) self.path.closeSubpath()
def setupMounts(self): adapter = app.adapterManager[0] if not adapter.useXwared: self.tab_mount.setEnabled(False) return self.table_mounts.setRowCount(0) self.table_mounts.clearContents() mountsMapping = app.adapterManager[0].mountsFaker.getMountsMapping() for i, mount in enumerate(app.adapterManager[0].mountsFaker.mounts): self.table_mounts.insertRow(i) # drive1: the drive letter it should map to, by alphabetical order drive1 = app.adapterManager[0].mountsFaker.driveIndexToLetter(i) self.table_mounts.setItem(i, 0, QTableWidgetItem(drive1 + "\\TDDOWNLOAD")) # mounts = ['/path/to/1', 'path/to/2', ...] self.table_mounts.setItem(i, 1, QTableWidgetItem(mount)) # drive2: the drive letter it actually is assigned to drive2 = mountsMapping.get(mount, "无") errors = [] # check: mapping if drive1 != drive2: errors.append( "错误:盘符映射在'{actual}',而不是'{should}'。\n" "如果这是个新挂载的文件夹,请尝试稍等,或重启后端,可能会修复此问题。" .format(actual = drive2, should = drive1)) brush = QBrush() if errors: brush.setColor(Qt.red) errString = "\n".join(errors) else: brush.setColor(Qt.darkGreen) errString = "正常" errWidget = QTableWidgetItem(errString) errWidget.setForeground(brush) self.table_mounts.setItem(i, 2, errWidget) del brush, errWidget self.table_mounts.resizeColumnsToContents()
def textureRect(self, rect_tile): tile_info = rect_tile.data(0) if tile_info is None: return False pm = QPixmap(self.__tiler.tile_to_path(tile_info)) if pm.width() != 256: #print("Probably didn't get tile:", next_tile_info.x, next_tile_info.y, "\n") #TODO: Attempt to texture with a lower res tile #Bear in mind that you will have to take Mercator projection into #account on the lower res tile. #First Attempt: didn't work #if tile_info.zoom <= self.__tiler.get_min_zoom(): # return False # #find colocated lower res tile #(lat,lon) = tile_info.coord() #tile_info2 = self.__tiler.coord_to_tile(lat,lon, tile_info.zoom-1) #rect_tile.setData(0, tile_info2) #print("prev tile: ", tile_info.tile, tile_info.coord()) #return self.textureRect(rect_tile, depth + 1) #until such time as we can pull lower res tiles and figure out #which area to render on a rectangle, skip: return False topLeft = rect_tile.boundingRect().topLeft() bottomRight = rect_tile.boundingRect().bottomRight() width = bottomRight.x() - topLeft.x() height = bottomRight.y() - topLeft.y() brush_trans = QTransform() brush_trans.translate(topLeft.x(), topLeft.y()) brush_trans.scale(width/256.0, height/256.0) qb = QBrush(pm) qb.setTransform(brush_trans) rect_tile.setBrush(qb) return True
def setupMounts(self): self.table_mounts.setRowCount(0) self.table_mounts.clearContents() permissionCheckResult = app.mountsFaker.permissionCheck() permissionCheckFailed = ["无法获得检测权限。运行{}查看原因。".format(constants.PERMISSIONCHECK)] mountsMapping = app.mountsFaker.getMountsMapping() for i, mount in enumerate(app.mountsFaker.mounts): # mounts = ['/path/to/1', 'path/to/2', ...] self.table_mounts.insertRow(i) self.table_mounts.setItem(i, 0, QTableWidgetItem(mount)) # drive1: the drive letter it should map to, by alphabetical order drive1 = chr(ord('C') + i) + ":" self.table_mounts.setItem(i, 1, QTableWidgetItem(drive1)) # drive2: the drive letter it actually is assigned to drive2 = mountsMapping.get(mount, "无") # check 1: permission errors = permissionCheckResult.get(mount, permissionCheckFailed) # check 2: mapping if drive1 != drive2: errors.append( "警告:盘符映射在'{actual}',而不是'{should}'。需要重启后端修复。".format( actual = drive2, should = drive1)) brush = QBrush() if errors: brush.setColor(Qt.red) errString = "\n".join(errors) else: brush.setColor(Qt.darkGreen) errString = "正常" errWidget = QTableWidgetItem(errString) errWidget.setForeground(brush) self.table_mounts.setItem(i, 2, errWidget) del brush, errWidget self.table_mounts.resizeColumnsToContents()
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)
class BrushFormation(InstrumentFormation): ''' Specialize to Qt <QBrush> ''' def __init__(self, parentSelector, role=""): InstrumentFormation.__init__(self, name="Brush", parentSelector=parentSelector, role=role) self.instrument = QBrush() self.styleProperties=[BaseStyleProperty("Color", self.instrument.setColor, self.selector, resettableValueFactory=ResettableColorValue, layoutFactory=ColorStylePropertyLayout, default=self.instrument.color()), BaseStyleProperty("Style", # Was Pattern self.instrument.setStyle, self.selector, default=self.instrument.style(), # ResettableIntValue defaults and works layoutFactory=ComboBoxStylePropertyLayout, domainModel = config.BrushModel),] ''' sic, BrushPattern is called Style in Qt Need Pattern, since defaults to NoBrush and that means color is moot. If we just have Color, once it is set, no way to go back to unfilled. TODO: user friendly: if user chooses color, ensure pattern is not NoBrush ''' # TODO gradients and texture not working? def applyTo(self, morph): #print "setBrush on morph", self.instrument.color() # Morph knows it's scale and applies it to self instrument morph.scaleInstrument(self.instrument) # No baseValue, defaults to 1 # Tell Morph to use self.instrument to draw itself morph.setBrush(self.instrument) """
class RoundedPushButton(QPushButton): def __init__(self,parent, text=''): QPushButton.__init__(self, parent) self.text=text self.backgroundColor = QPalette().light().color() self.backgroundColor.setRgb(157,157,157) #(220,203,231) #self.backgroundColor.setAlpha(0) self.brush=QBrush(Qt.SolidPattern) def paintEvent(self,event): 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.width(),self.height()), self.width()/10, self.height()/10) self.painter.end() self.painter3=QPainter(self) self.painter3.drawText(1,0,self.width()-2,self.height(),Qt.AlignCenter,self.text) self.painter3.end()
def setupMounts(self): self.table_mounts.setRowCount(0) self.table_mounts.clearContents() PermissionError = self.permissionCheck() mountsMapping = self.mainWin.mountsFaker.getMountsMapping() for i, mount in enumerate(self.mainWin.mountsFaker.mounts): # mounts = ['/path/to/1', 'path/to/2', ...] self.table_mounts.insertRow(i) self.table_mounts.setItem(i, 0, QTableWidgetItem(mount)) drive1 = chr(ord('C') + i) + ":" # the drive letter it should map to, by alphabetical order self.table_mounts.setItem(i, 1, QTableWidgetItem(drive1)) drive2 = mountsMapping.get(mount, "无") # the drive letter it actually is assigned to # check 1: permission errors = PermissionError.get(mount, ["无法获得检测权限。运行/opt/xware_desktop/permissioncheck查看原因。"]) # check 2: mapping if drive1 != drive2: errors.append("警告:盘符映射在'{actual}',而不是'{should}'。需要重启后端修复。".format(actual = drive2, should = drive1)) from PyQt5.Qt import Qt from PyQt5.QtGui import QBrush brush = QBrush() if errors: brush.setColor(Qt.red) errString = "\n".join(errors) else: brush.setColor(Qt.darkGreen) errString = "正常" errWidget = QTableWidgetItem(errString) errWidget.setForeground(brush) self.table_mounts.setItem(i, 2, errWidget) del brush, errWidget self.table_mounts.resizeColumnsToContents()
def init(self): current_path = os.path.dirname(os.path.abspath(__file__)).split(os.sep) current_path = os.path.join(*current_path[1:-2]) default_image_path = "/" + current_path + "/test/fakeimg.jpg" image_path = self.getProperty("file_name", default_image_path) self.image = QPixmap(image_path) self.image_dimensions = (self.image.width(), self.image.height()) self.painter = QPainter(self.image) custom_pen = QPen(Qt.SolidLine) custom_pen.setColor(Qt.black) custom_pen.setWidth(1) self.painter.setPen(custom_pen) custom_brush = QBrush(Qt.SolidPattern) custom_brush.setColor(Qt.lightGray) self.painter.setBrush(custom_brush) self.setIsReady(True) AbstractVideoDevice.init(self)
def __init__(self, parent=None): super(ColorPanel, self).__init__(parent) self.rect = QRectF(0, 0, 30, 30) self.setFlag(QGraphicsItem.ItemIgnoresTransformations) self.colordialog = QColorDialog() # self.colordialog.setOption(QColorDialog.DontUseNativeDialog) self._scaf_color_index = -1 # init on -1, painttool will cycle to 0 self._stap_color_index = -1 # init on -1, painttool will cycle to 0 self._scaf_color = self._scaf_colors[self._scaf_color_index] self._stap_color = self._stap_colors[self._stap_color_index] self._scaf_brush = QBrush(self._scaf_color) self._stap_brush = QBrush(self._stap_color) self._initLabel() self.hide()
def __init__(self,parent): super(WLLineLabel,self).__init__(parent) self.setWindowFlags(Qt.FramelessWindowHint ) self.linelength=1000 self.lineheight=5 self.resize(self.linelength, self.lineheight) self.move(100,100) self.stats=None #self.setStyleSheet("{background-color:transparent;border:none;color:transparent;}") self.backgroundColor = QPalette().light().color() self.backgroundColor.setRgb(157,157,157)#(220,203,231) #self.backgroundColor.setAlpha(255) self.brush=QBrush(Qt.SolidPattern)
def __init__(self, brojIgraca, lvlNumber, menu_widnow): super().__init__() self.menu_window = menu_widnow oImage = QImage("images\\dk.jpg") sImage = oImage.scaled(QSize(1000, 562)) # resize Image to widgets size palette = QPalette() palette.setBrush(10, QBrush(sImage)) # 10 = Windowrole self.setPalette(palette) self.barrelsMovement = None self.pix112 = QPixmap('images\\luigiL.png') self.pix11 = QPixmap('images\\luigi.png') self.pix12 = QPixmap('images\\marioL.jpg') self.pix1 = QPixmap('images\\mario.jpg') self.pix2 = QPixmap('images\\p.png') self.pix22 = QPixmap('images\\pL.png') self.pix3 = QPixmap('images\\donkeykong1.png') self.pixBottleR = QPixmap('images\\barrelR.png') self.pix32 = QPixmap('images\\donkeykong1.png') self.pixfire = QPixmap('images\\fire.png') self.hitSide = False self.barrels_speed = 0.1 #promeljiva za brzinu self.label2 = QLabel(self) self.label12 = QLabel(self) self.label4 = QLabel(self) self.label3 = QLabel(self) self.labelScore = QLabel(self) self.labelLifes1 = QLabel(self) self.labelLifes2 = QLabel(self) self.life1ispis = QLabel(self) self.life2ispis = QLabel(self) self.label1 = QLabel(self) self.labelLevel = QLabel(self) self.ispisLabel1 = QLabel(self) self.playerRez1 = QLabel(self) self.playerRez11 = QLabel(self) self.playerRez2 = QLabel(self) self.playerRez22 = QLabel(self) self.barrelQueue = Queue() self.barrelProcess = Process(target=generateBarrel, args=[self.barrelQueue]) self.barrels = [] self.barrelProcess.start() self.gorilaStop = Queue() self.gorilaStart = Queue() self.gorilaBug = Process(target=GorilaFreezeProcess, args=[self.gorilaStart, self.gorilaStop]) self.gorilaBug.start() self.fire_positions = [[400, 400], [500, 400], [550, 400],[700,310],[220,310]] self.firelabel = QLabel(self) self.firelabel.setPixmap(self.pixfire) self.zaustavio = False self.PointsM = 0 self.PointsL = 0 self.trenutniNivo = lvlNumber self.kraj = None self.quit_menu = QLabel(self) self.quit_img = QPixmap('images\\menubutton.png') self.quit_menu.setPixmap(self.quit_img) self.quit_menu.setGeometry(800, 50, 75, 50) self.quit_menu.mousePressEvent = self.go_to_menu self.ispisLabel1.setText('Level: ') self.ispisLabel1.setStyleSheet('color: blue') self.playerRez1.setText('P1: ') self.playerRez1.setStyleSheet('color: red') self.playerRez2.setText('P2: ') self.life1ispis.setText('P1 Life: ') self.life1ispis.setStyleSheet('color: red') self.life2ispis.setText('P2 Life: ') self.playerRez11.setText(str(self.PointsM)) self.playerRez11.setStyleSheet('color: red') self.playerRez22.setText(str(self.PointsL)) self.left = 400 self.top = 200 self.width = 1000 self.height = 562 self.key_notifier = KeyNotifier() if (brojIgraca == 1): self.key_notifier.key_signal.connect(self.__update_position__) self.brojIgracaJedan = True else: self.brojIgracaJedan = False self.key_notifier2 = KeyNotifier2() self.key_notifier.key_signal.connect(self.__update_position__) # ----------------- self.key_notifier2.key_signal2.connect(self.__update_position2__) # ----------------- self.key_notifier2.start() self.key_notifier.start() self.__init_ui__(brLevel, brojIgraca)
class EmptyHelixItem(QGraphicsEllipseItem): """docstring for EmptyHelixItem""" # set up default, hover, and active drawing styles _DEFAULT_BRUSH = QBrush(styles.GRAY_FILL) _DEFAULT_PEN = QPen(styles.GRAY_STROKE, styles.SLICE_HELIX_STROKE_WIDTH) _HOVER_BRUSH = QBrush(styles.BLUE_FILL) _HOVER_PEN = QPen(styles.BLUE_STROKE, styles.SLICE_HELIX_HILIGHT_WIDTH) _RADIUS = styles.SLICE_HELIX_RADIUS temp = styles.SLICE_HELIX_STROKE_WIDTH _DEFAULT_RECT = QRectF(0, 0, 2 * _RADIUS, 2 * _RADIUS) temp = (styles.SLICE_HELIX_HILIGHT_WIDTH - temp) / 2 _HOVER_RECT = _DEFAULT_RECT.adjusted(-temp, -temp, temp, temp) _Z_DEFAULT = styles.ZSLICEHELIX _Z_HOVERED = _Z_DEFAULT + 1 temp /= 2 _ADJUSTMENT_PLUS = (temp, temp) _ADJUSTMENT_MINUS = (-temp, -temp) # _PI = 3.141592 # _temp = [x*_PI*0.1 for x in range(20)] # _temp = [(math.sin(angle) * _RADIUS, math.cos(angle) * _RADIUS) for angle in _temp] def __init__(self, row, column, part_item): """ row, column is a coordinate in Lattice terms part_item is a PartItem that will act as a QGraphicsItem parent """ super(EmptyHelixItem, self).__init__(parent=part_item) self._part_item = part_item self._lastvh = None # for decideAction self.hide() self._is_hovered = False self.setAcceptHoverEvents(True) self.setNotHovered() x, y = part_item.part().latticeCoordToPositionXY( row, column, part_item.scaleFactor()) self.setPos(x, y) self._coord = (row, column) self.show() # end def def virtualHelix(self): """ virtualHelixItem should be the HelixItems only child if it exists and virtualHelix should be it member """ temp = self.virtualHelixItem() if temp: return temp.virtualHelix() else: return None # end def def virtualHelixItem(self): """ virtualHelixItem should be the HelixItems only child if it exists and virtualHelix should be it member """ temp = self.childItems() if len(temp) > 0: return temp[0] else: return None # end def def part(self): return self._part_item.part() # end def def translateVH(self, delta): """ used to update a child virtual helix position on a hover event delta is a tuple of x and y values to translate positive delta happens when hover happens negative delta when something unhovers """ temp = self.virtualHelixItem() # xor the check to translate, # convert to a QRectF adjustment if necessary check = (delta > 0) ^ self._is_hovered if temp and check: pass # temp.translate(*delta) # end def def setHovered(self): # self.setFlag(QGraphicsItem.ItemHasNoContents, False) self.setBrush(self._HOVER_BRUSH) self.setPen(self._HOVER_PEN) self.update(self.boundingRect()) # self.translateVH(self._ADJUSTMENT_PLUS) self._is_hovered = True self.setZValue(self._Z_HOVERED) self.setRect(self._HOVER_RECT) self._part_item.updateStatusBar("(%d, %d)" % self._coord) # end def def hoverEnterEvent(self, event): """ hoverEnterEvent changes the HelixItem brush and pen from default to the hover colors if necessary. """ self.setHovered() # end def def setNotHovered(self): """ """ # drawMe = False if self.virtualHelixItem() else True # self.setFlag(QGraphicsItem.ItemHasNoContents, drawMe) self.setBrush(self._DEFAULT_BRUSH) self.setPen(self._DEFAULT_PEN) # self.translateVH(self._ADJUSTMENT_MINUS) self._is_hovered = False self.setZValue(self._Z_DEFAULT) self.setRect(self._DEFAULT_RECT) self._part_item.updateStatusBar("") # end def def hoverLeaveEvent(self, event): """ hoverEnterEvent changes the HelixItem brush and pen from hover to the default colors if necessary. """ self.setNotHovered() # end def def mousePressEvent(self, event): action = self.decideAction(event.modifiers()) action(self) self.dragSessionAction = action # end def def mouseMoveEvent(self, event): part_item = self._part_item pos_in_parent = part_item.mapFromItem(self, QPointF(event.pos())) # Qt doesn't have any way to ask for graphicsitem(s) at a # particular position but it *can* do intersections, so we # just use those instead part_item.probe.setPos(pos_in_parent) for ci in part_item.probe.collidingItems(): if isinstance(ci, EmptyHelixItem): self.dragSessionAction(ci) # end def def autoScafMidSeam(self, strands): """docstring for autoScafMidSeam""" part = self.part() strand_type = StrandType.SCAFFOLD idx = part.activeBaseIndex() for i in range(1, len(strands)): row1, col1, ss_idx1 = strands[i - 1] # previous strand row2, col2, ss_idx2 = strands[i] # current strand vh1 = part.virtualHelixAtCoord((row1, col1)) vh2 = part.virtualHelixAtCoord((row2, col2)) strand1 = vh1.scaffoldStrandSet()._strand_list[ss_idx1] strand2 = vh2.scaffoldStrandSet()._strand_list[ss_idx2] # determine if the pair of strands are neighbors neighbors = part.getVirtualHelixNeighbors(vh1) if vh2 in neighbors: p2 = neighbors.index(vh2) if vh2.number() % 2 == 1: # resize and install external xovers try: # resize to the nearest prexover on either side of idx new_lo = util.nearest( idx, part.getPreXoversHigh(strand_type, p2, max_idx=idx - 10)) new_hi = util.nearest( idx, part.getPreXoversLow(strand_type, p2, min_idx=idx + 10)) if strand1.canResizeTo(new_lo, new_hi) and \ strand2.canResizeTo(new_lo, new_hi): # do the resize strand1.resize((new_lo, new_hi)) strand2.resize((new_lo, new_hi)) # install xovers part.createXover(strand1, new_hi, strand2, new_hi) part.createXover(strand2, new_lo, strand1, new_lo) except ValueError: pass # nearest not found in the expanded list # go back an install the internal xovers if i > 2: row0, col0, ss_idx0 = strands[i - 2] # two strands back vh0 = part.virtualHelixAtCoord((row0, col0)) strand0 = vh0.scaffoldStrandSet()._strand_list[ss_idx0] if vh0 in neighbors: p0 = neighbors.index(vh0) l0, h0 = strand0.idxs() l1, h1 = strand1.idxs() o_low, o_high = util.overlap(l0, h0, l1, h1) try: l_list = list(filter(lambda x: x > o_low and \ x < o_high, part.getPreXoversLow(strand_type, p0))) l_x = l_list[len(l_list) // 2] h_list = list(filter(lambda x: x > o_low and \ x < o_high, part.getPreXoversHigh(strand_type, p0))) h_x = h_list[len(h_list) // 2] # install high xover first part.createXover(strand0, h_x, strand1, h_x) # install low xover after getting new strands # following the breaks caused by the high xover strand3 = vh0.scaffoldStrandSet( )._strand_list[ss_idx0] strand4 = vh1.scaffoldStrandSet( )._strand_list[ss_idx1] part.createXover(strand4, l_x, strand3, l_x) except IndexError: pass # filter was unhappy def autoScafRaster(self, strands): """docstring for autoScafRaster""" part = self.part() idx = part.activeBaseIndex() for i in range(1, len(strands)): row1, col1, ss_idx1 = strands[i - 1] # previous strand row2, col2, ss_idx2 = strands[i] # current strand vh1 = part.virtualHelixAtCoord((row1, col1)) vh2 = part.virtualHelixAtCoord((row2, col2)) strand1 = vh1.scaffoldStrandSet()._strand_list[ss_idx1] strand2 = vh2.scaffoldStrandSet()._strand_list[ss_idx2] # determine if the pair of strands are neighbors neighbors = part.getVirtualHelixNeighbors(vh1) if vh2 in neighbors: p2 = neighbors.index(vh2) if vh2.number() % 2 == 1: # resize and install external xovers try: # resize to the nearest prexover on either side of idx new_lo1 = new_lo2 = util.nearest( idx, part.getPreXoversHigh(StrandType.SCAFFOLD, p2, max_idx=idx - 8)) new_hi = util.nearest( idx, part.getPreXoversLow(StrandType.SCAFFOLD, p2, min_idx=idx + 8)) if vh1.number() != 0: # after the first helix new_lo1 = strand1.lowIdx( ) # leave alone the lowIdx if vh2.number() != len(strands) - 1: # before the last new_lo2 = strand2.lowIdx( ) # leave alone the lowIdx if strand1.canResizeTo(new_lo1, new_hi) and \ strand2.canResizeTo(new_lo2, new_hi): strand1.resize((new_lo1, new_hi)) strand2.resize((new_lo2, new_hi)) else: raise ValueError # install xovers part.createXover(strand1, new_hi, strand2, new_hi) except ValueError: pass # nearest not found in the expanded list else: # resize and install external xovers idx = part.activeBaseIndex() try: # resize to the nearest prexover on either side of idx new_lo = util.nearest( idx, part.getPreXoversHigh(StrandType.SCAFFOLD, p2, max_idx=idx - 8)) if strand1.canResizeTo(new_lo, strand1.highIdx()) and \ strand2.canResizeTo(new_lo, strand2.highIdx()): strand1.resize((new_lo, strand1.highIdx())) strand2.resize((new_lo, strand2.highIdx())) # install xovers part.createXover(strand1, new_lo, strand2, new_lo) else: raise ValueError except ValueError: pass # nearest not found in the expanded list def mouseReleaseEvent(self, event): """docstring for mouseReleaseEvent""" part = self.part() u_s = part.undoStack() strands = [] # Look at the undo stack in reverse order for i in range(u_s.index() - 1, 0, -1): # Check for contiguous strand additions m = _strand_re.match(u_s.text(i)) if m: strands.insert(0, list(map(int, m.groups()))) else: break if len(strands) > 1: auto_scaf_type = app().prefs.getAutoScafType() util.beginSuperMacro(part, "Auto-connect") if auto_scaf_type == "Mid-seam": self.autoScafMidSeam(strands) elif auto_scaf_type == "Raster": self.autoScafRaster(strands) util.endSuperMacro(part) def decideAction(self, modifiers): """ On mouse press, an action (add scaffold at the active slice, add segment at the active slice, or create virtualhelix if missing) is decided upon and will be applied to all other slices happened across by mouseMoveEvent. The action is returned from this method in the form of a callable function.""" vh = self.virtualHelix() part = self.part() if vh == None: return EmptyHelixItem.addVHIfMissing idx = part.activeBaseIndex() scafSSet, stapSSet = vh.getStrandSets() if modifiers & Qt.ShiftModifier: if not stapSSet.hasStrandAt(idx - 1, idx + 1): return EmptyHelixItem.addStapAtActiveSliceIfMissing else: return EmptyHelixItem.nop if not scafSSet.hasStrandAt(idx - 1, idx + 1): return EmptyHelixItem.addScafAtActiveSliceIfMissing return EmptyHelixItem.nop # end def def nop(self): self._part_item.updateStatusBar("(%d, %d)" % self._coord) def addScafAtActiveSliceIfMissing(self): vh = self.virtualHelix() part = self.part() if vh == None: return idx = part.activeBaseIndex() start_idx = max(0, idx - 1) end_idx = min(idx + 1, part.maxBaseIdx()) vh.scaffoldStrandSet().createStrand(start_idx, end_idx) self._part_item.updateStatusBar("(%d, %d)" % self._coord) # end def def addStapAtActiveSliceIfMissing(self): vh = self.virtualHelix() part = self.part() if vh == None: return idx = part.activeBaseIndex() start_idx = max(0, idx - 1) end_idx = min(idx + 1, part.maxBaseIdx()) vh.stapleStrandSet().createStrand(start_idx, end_idx) self._part_item.updateStatusBar("(%d, %d)" % self._coord) # end def def addVHIfMissing(self): vh = self.virtualHelix() coord = self._coord part = self.part() if vh != None: return u_s = part.undoStack() u_s.beginMacro("Slice Click") part.createVirtualHelix(*coord) # vh.scaffoldStrandSet().createStrand(start_idx, end_idx) u_s.endMacro() self._part_item.updateStatusBar("(%d, %d)" % self._coord) # end def if GL: def paint(self, painter, option, widget): painter.beginNativePainting() radius = self._RADIUS # GL.glPushAttrib(GL.GL_ALL_ATTRIB_BITS) # GL.glClear(GL.GL_COLOR_BUFFER_BIT) # Draw the filled circle GL.glColor3f(1, 0.5, 0) # Set to orange GL.glBegin(GL.GL_POLYGON) for X, Y in self._temp: GL.glVertex2f(X, Y) # end for GL.glEnd() # Draw the anti-aliased outline # GL.glEnable(GL.GL_BLEND) # GL.glBlendFunc(GL.GL_SRC_ALPHA, GL.GL_ONE_MINUS_SRC_ALPHA) # GL.glEnable(GL.GL_LINE_SMOOTH) # GL.glBegin(GL.GL_LINE_LOOP) # for angle in [x*PI*0.01 for x in range(200)]: # GL.glVertex2f(X + math.sin(angle) * radius, Y + math.cos(angle) * radius) # # end for # GL.glDisable(GL.GL_BLEND) # GL.glEnd() # GL.glPopAttrib() painter.endNativePainting()
def setBackgroundColor(self, color): """ add background color """ brush = QBrush(color) self.scene.setBackgroundBrush(brush) self.scene.backgroundBrush()
def __init__(self, freq, samp_rate, bw, gain, device: str, mode: Mode, modulated_data=None, parent=None, testing_mode=False): super().__init__(parent) self.ui = Ui_SendRecvDialog() self.ui.setupUi(self) self.setAttribute(Qt.WA_DeleteOnClose) self.graphics_view = self.ui.graphicsViewSend if mode == Mode.send else self.ui.graphicsViewReceive self.backend_handler = BackendHandler(testing_mode=testing_mode) if mode == Mode.spectrum: self.update_interval = 1 else: self.update_interval = 50 if mode == Mode.send and modulated_data is None: raise ValueError("I need modulated data to send!") if mode == Mode.receive or mode == Mode.spectrum: self.ui.spinBoxNRepeat.hide() self.ui.labelNRepeat.hide() self.ui.lblCurrentRepeatValue.hide() self.ui.lblRepeatText.hide() self.ui.lSamplesSentText.hide() self.ui.progressBar.hide() self.ui.stackedWidget.setCurrentIndex(0) else: self.ui.stackedWidget.setCurrentIndex(1) if mode == Mode.send or mode == Mode.spectrum: self.ui.lSamplesCaptured.hide() self.ui.lSamplesCapturedText.hide() self.ui.lSignalSize.hide() self.ui.lSignalSizeText.hide() self.ui.lTime.hide() self.ui.lTimeText.hide() self.ui.btnSave.hide() if mode == Mode.spectrum: self.setWindowTitle("Spectrum analyzer") if mode == Mode.send: self.ui.btnStart.setIcon(QIcon.fromTheme("media-playback-start")) self.setWindowTitle("Send signal") self.ui.btnStart.setToolTip("Send data") self.ui.btnStop.setToolTip("Stop sending") self.ui.progressBar.setMaximum(len(modulated_data)) self.device_is_sending = False self.ui.btnStop.setEnabled(False) self.ui.btnClear.setEnabled(False) self.ui.btnSave.setEnabled(False) self.start = 0 self.already_saved = True self.bw_sr_are_locked = constants.SETTINGS.value( "lock_bandwidth_sample_rate", True, bool) self.ui.spinBoxFreq.setValue(freq) self.ui.spinBoxSampleRate.setValue(samp_rate) self.ui.spinBoxBandwidth.setValue(bw) self.ui.spinBoxGain.setValue(gain) self.ui.spinBoxNRepeat.setValue( constants.SETTINGS.value('num_sending_repeats', 1, type=int)) self.ui.cbDevice.clear() items = [] for device_name in self.backend_handler.DEVICE_NAMES: dev = self.backend_handler.device_backends[device_name.lower()] if mode == Mode.send and dev.is_enabled and dev.supports_tx: items.append(device_name) elif mode in (Mode.receive, Mode.spectrum ) and dev.is_enabled and dev.supports_rx: items.append(device_name) if mode == Mode.send and PluginManager().is_plugin_enabled( "NetworkSDRInterface"): items.append(NetworkSDRInterfacePlugin.NETWORK_SDR_NAME) self.ui.cbDevice.addItems(items) if device in items: self.ui.cbDevice.setCurrentIndex(items.index(device)) dev_name = self.ui.cbDevice.currentText() nrep = self.ui.spinBoxNRepeat.value() self.device = VirtualDevice(self.backend_handler, dev_name, mode, bw, freq, gain, samp_rate, samples_to_send=modulated_data, device_ip=self.ui.lineEditIP.text(), sending_repeats=nrep, parent=self) self.ui.lineEditIP.setVisible(dev_name == "USRP") self.ui.labelIP.setVisible(dev_name == "USRP") self.recorded_files = [] self.timer = QTimer(self) if mode == Mode.receive: self.scene_manager = LiveSceneManager(np.array( []), parent=self) # set really in on_device_started elif mode == Mode.send: signal = Signal.from_samples(modulated_data, "Modulated Preview", samp_rate) self.scene_manager = SignalSceneManager(signal, parent=self) self.send_indicator = self.scene_manager.scene.addRect( 0, -2, 0, 4, QPen(QColor(Qt.transparent), Qt.FlatCap), QBrush(constants.SEND_INDICATOR_COLOR)) self.send_indicator.stackBefore( self.scene_manager.scene.selection_area) self.scene_manager.init_scene() self.graphics_view.set_signal(signal) self.graphics_view.sample_rate = samp_rate else: self.scene_manager = FFTSceneManager( parent=self, graphic_view=self.graphics_view) self.graphics_view.setScene(self.scene_manager.scene) self.graphics_view.scene_manager = self.scene_manager ipRange = "(?:[0-1]?[0-9]?[0-9]|2[0-4][0-9]|25[0-5])" ipRegex = QRegExp("^" + ipRange + "\\." + ipRange + "\\." + ipRange + "\\." + ipRange + "$") self.ui.lineEditIP.setValidator(QRegExpValidator(ipRegex)) self.create_connects() self.ui.btnLockBWSR.setChecked(self.bw_sr_are_locked) self.on_btn_lock_bw_sr_clicked()
fmt.setSamples(10) QSurfaceFormat.setDefaultFormat(fmt) scene = MyScene(0., 0., 600., 400.) path = QPainterPath() path.moveTo(0, 0) path.lineTo(50, 110) path2 = QPainterPath() path2.moveTo(50, -10) path2.lineTo(50, 220) scene.addPath(path2, QPen(Qt.black)) scene.addRect(QRectF(0, 0, 100, 200), QPen(Qt.transparent), QBrush(Qt.green)) scene.addRect(QRectF(200, 0, 100, 200), QPen(Qt.transparent), QBrush(Qt.red)) scene.addPath(path, QPen(Qt.black), QBrush(Qt.green)) scene.addText("I Love Qt Programming", QFont("Times", 22, QFont.Bold)) view = MyView(scene) view.setViewport(QOpenGLWidget()) view.setRenderHints(QPainter.HighQualityAntialiasing) view.show() layout = QGridLayout() app.exec()
def createRow(self, param, name_editable=False, value_editable=True, comments_editable=True, index=-1): """ Create a row in the table for a param. Input: param: ParamNode Return: BaseRowItem derived object """ row = self.rowCount() if index >= 0: row = index self.insertRow(row) name_item = QtWidgets.QTableWidgetItem(param.name) name_item.setData(Qt.UserRole, param) if not name_editable: name_item.setFlags(Qt.ItemIsEnabled) if param.required: color = QColor(255, 204, 153) brush = QBrush(color) name_item.setBackground(brush) elif param.user_added: color = QColor("cyan") brush = QBrush(color) name_item.setBackground(brush) name_item.setText(param.name) self.setItem(row, 0, name_item) if param.cpp_type == "bool": checkbox = QtWidgets.QCheckBox() if param.value == "true": checkbox.setCheckState(Qt.Checked) else: checkbox.setCheckState(Qt.Unchecked) checkbox.pressed.connect(self.changed) self.setCellWidget(row, 1, checkbox) else: value_item = QtWidgets.QTableWidgetItem(param.value) if not value_editable or param.name == "type": value_item.setFlags(Qt.ItemIsEnabled) else: name_item.setToolTip(param.toolTip()) self.setItem(row, 1, value_item) comments_item = QtWidgets.QTableWidgetItem(param.comments) if not comments_editable: comments_item.setFlags(Qt.ItemIsEnabled) self.setItem(row, 3, comments_item) watch_blocks = self._getChildrenOfNodeOptions(param.cpp_type) if param.cpp_type == "FileName" or param.cpp_type == "MeshFileName" or param.cpp_type == "FileNameNoExtension": self._createFilenameOption(param) elif watch_blocks: self._createBlockWatcher(param, watch_blocks) elif param.options: self._createOptions(param) elif param.user_added: button = QtWidgets.QPushButton("Remove") button.clicked.connect( lambda checked: self._removeButtonClicked(name_item)) self.setCellWidget(row, 2, button) else: option_item = QtWidgets.QTableWidgetItem() option_item.setFlags(Qt.NoItemFlags) self.setItem(row, 2, option_item)
def addCategory(self, title): item = QListWidgetItem(title) item.setBackground(QBrush(QColor(S.highlightLight))) item.setForeground(QBrush(QColor(S.highlightedTextDark))) item.setFlags(Qt.ItemIsEnabled) self.list.addItem(item)
class GameViewer(QWidget): ''' The main game viewer GUI ''' # Define the colours used for drawing everything wall_brush = QBrush(QColor("black")) wall_pen = QPen(wall_brush, 0) goody0_brush = QBrush(QColor("#00CC00")) goody0_pen = QPen(goody0_brush, 0) goody1_brush = QBrush(QColor("green")) goody1_pen = QPen(goody1_brush, 0) baddy_brush = QBrush(QColor("red")) baddy_pen = QPen(baddy_brush, 0) ping_brush = QBrush(QColor("white")) def __init__(self): super(GameViewer, self).__init__() self.cell_size = 100 # Arbitrary units self.scene = None self.game = None self.game_generator = None self.goody0 = None self.goody1 = None self.baddy = None self.ping_marker = {} self.results = defaultdict(int) self.round_timer = QTimer(interval=50, timeout=self._play) # milliseconds self.running = False self.view = QGraphicsView() self.view.scale(1, -1) # We want x to increase rightwards and y to increase upwards self.view.setMinimumSize(500, 500) self.round = QLabel() self.status = QLabel() self.goodies_win_count = QLineEdit(readOnly=True) self.draw_count = QLineEdit(readOnly=True) self.baddy_wins_count = QLineEdit(readOnly=True) self.auto_start = QCheckBox("Auto-start new game", checked=True) self.new_game_button = QPushButton("&New Game", clicked=self.new_game, enabled=False) self.step_button = QPushButton("S&tep", clicked=self.do_round, enabled=False) self.go_stop_button = QPushButton("&Go", clicked=self.toggle_running, enabled=False) stats_layout = QHBoxLayout() stats_layout.addWidget(QLabel("Goodies:")) stats_layout.addWidget(self.goodies_win_count) stats_layout.addWidget(QLabel("Draw:")) stats_layout.addWidget(self.draw_count) stats_layout.addWidget(QLabel("Baddy:")) stats_layout.addWidget(self.baddy_wins_count) legend_layout = QHBoxLayout() pixmap = QPixmap(16, 16) pixmap.fill(self.goody0_brush.color()) goody0_icon = QLabel() goody0_icon.setPixmap(pixmap) legend_layout.addWidget(goody0_icon) self.goody0_name = QLabel() legend_layout.addWidget(self.goody0_name) legend_layout.addStretch(1) pixmap.fill(self.goody1_brush.color()) goody1_icon = QLabel() goody1_icon.setPixmap(pixmap) legend_layout.addWidget(goody1_icon) self.goody1_name = QLabel() legend_layout.addWidget(self.goody1_name) legend_layout.addStretch(1) pixmap.fill(self.baddy_brush.color()) baddy_icon = QLabel() baddy_icon.setPixmap(pixmap) legend_layout.addWidget(baddy_icon) self.baddy_name = QLabel() legend_layout.addWidget(self.baddy_name) info_layout = QFormLayout() info_layout.addRow("Round:", self.round) info_layout.addRow("Status:", self.status) info_layout.addRow(stats_layout) buttons_layout = QHBoxLayout() buttons_layout.addWidget(self.new_game_button) buttons_layout.addWidget(self.step_button) buttons_layout.addWidget(self.go_stop_button) layout = QVBoxLayout(self) layout.addWidget(self.view) layout.addLayout(legend_layout) layout.addLayout(info_layout) layout.addWidget(self.auto_start) layout.addLayout(buttons_layout) def set_game(self, game): ''' Set the Game object that should be viewed by this GUI ''' if self.running: self.toggle_running() # Alter the GUI widgets self.game = game self.scene = QGraphicsScene(self) self.view.setScene(self.scene) self.go_stop_button.setEnabled(True) self.step_button.setEnabled(True) height = game.maze.height width = game.maze.width cell = self.cell_size # Leave a border of cell_size units, and put (0, 0) at the bottom corner of the maze's interior self.scene.setSceneRect(-cell, -cell, (width + 2) * cell, (height + 2) * cell) self.view.fitInView(self.scene.sceneRect()) # Create the border self.scene.addRect(-cell, -cell, (width + 2) * cell, cell, pen=self.wall_pen, brush=self.wall_brush) self.scene.addRect(-cell, height * cell, (width + 2) * cell, cell, pen=self.wall_pen, brush=self.wall_brush) self.scene.addRect(-cell, 0, cell, height * cell, pen=self.wall_pen, brush=self.wall_brush) self.scene.addRect(width * cell, 0, cell, height * cell, pen=self.wall_pen, brush=self.wall_brush) # Add the obstructions: for y in range(width): for x in range(height): if game.maze[x, y] == Maze.wall: self.scene.addRect(x * cell, y * cell, cell, cell, pen=self.wall_pen, brush=self.wall_brush) # Add the players goody0_pos = game.position[game.goody0] goody1_pos = game.position[game.goody1] baddy_pos = game.position[game.baddy] self.goody0 = self.scene.addEllipse(0, 0, cell, cell, pen=self.goody0_pen, brush=self.goody0_brush) self.goody0.setPos(goody0_pos.x * cell, goody0_pos.y * cell) self.goody1 = self.scene.addEllipse(0, 0, cell, cell, pen=self.goody1_pen, brush=self.goody1_brush) self.goody1.setPos(goody1_pos.x * cell, goody1_pos.y * cell) self.baddy = self.scene.addEllipse(0, 0, cell, cell, pen=self.baddy_pen, brush=self.baddy_brush) self.baddy.setPos(baddy_pos.x * cell, baddy_pos.y * cell) # Add the ping markers for player, pen in ((game.goody0, self.goody0_pen), (game.goody1, self.goody1_pen), (game.baddy, self.baddy_pen)): marker = self.scene.addEllipse(cell // 4, cell // 4, cell // 2, cell // 2, pen=pen, brush=self.ping_brush) marker.hide() marker.setZValue(-1) self.ping_marker[player] = marker # Set the info self.round.setText(str(game.round)) self.status.setText(game.status) self.running = False # Update the legend self.goody0_name.setText(type(game.goody0).__name__) self.goody1_name.setText(type(game.goody1).__name__) self.baddy_name.setText(type(game.baddy).__name__) # Change the window title self.setWindowTitle("{} and {} vs. {}".format(type(game.goody0).__name__, type(game.goody1).__name__, type(game.baddy).__name__)) def set_game_generator(self, game_generator): ''' Set the game generator (a generator of Game instances) that the GUI can take from ''' self.game_generator = game_generator self.new_game_button.setEnabled(True) self.new_game() def new_game(self): ''' Take the next Game from the generator ''' if self.game_generator is not None: self.set_game(next(self.game_generator)) def toggle_running(self): ''' Switch between automatically stepping through the game and allowing manual "Step" clicks ''' if self.running: self.round_timer.stop() self.running = False else: self.round_timer.start() self.running = True self._update_widgets() def _play(self): ''' Private - called to do a round of turns and check if the game has ended ''' result = self.do_round() if result != Game.in_play: self.toggle_running() if not self.running and self.auto_start.isChecked(): self.new_game() self.toggle_running() def _update_widgets(self): ''' Private - Make the GUI show the current state of the Game ''' if self.running: self.go_stop_button.setText("&Stop") self.step_button.setEnabled(False) else: self.go_stop_button.setText("&Go") if self.game.status == Game.in_play: self.step_button.setEnabled(True) else: self.go_stop_button.setEnabled(False) self.step_button.setEnabled(False) self.goodies_win_count.setText(str(self.results[Game.goodies_win])) self.draw_count.setText(str(self.results[Game.draw])) self.baddy_wins_count.setText(str(self.results[Game.baddy_wins])) def do_round(self): ''' Take a round of turns ''' self.started = True game = self.game if game is None: return result = game.do_round() for graphic, player in ((self.goody0, game.goody0), (self.goody1, game.goody1), (self.baddy, game.baddy)): new_pos = game.position[player] new_x = new_pos.x * self.cell_size new_y = new_pos.y * self.cell_size graphic.setPos(new_x, new_y) if game.ping: marker = self.ping_marker[player] marker.setPos(new_x, new_y) marker.show() if result != Game.in_play: self.results[result] += 1 if not self.running: self._update_widgets() self.round.setText(str(self.game.round)) self.status.setText(self.game.status) return result
def drawBackground(self): side = min(self.width(), self.height()) ''' Keep side size an even number by trunkating odd pixel ''' side &= ~0x01 gradient = QRadialGradient() painter = QPainter(self) pen = QPen(Qt.black) pen.setWidth(1) ''' Initialize painter ''' painter.setRenderHint(QPainter.Antialiasing) painter.translate(self.width() / 2, self.height() / 2) painter.scale(side / 256.0, side / 256.0) painter.setPen(pen) ''' Draw external circle ''' gradient = QRadialGradient(QPointF(-128, -128), 384, QPointF(-128, -128)) gradient.setColorAt(0, QColor(224, 224, 224)) gradient.setColorAt(1, QColor(28, 28, 28)) painter.setPen(pen) painter.setBrush(QBrush(gradient)) painter.drawEllipse(QPoint(0, 0), 125, 125) ''' Draw inner circle ''' gradient = QRadialGradient(QPointF(128, 128), 384, QPointF(128, 128)) gradient.setColorAt(0, QColor(224, 224, 224)) gradient.setColorAt(1, QColor(28, 28, 28)) painter.setPen(Qt.NoPen) painter.setBrush(QBrush(gradient)) painter.drawEllipse(QPoint(0, 0), 118, 118) ''' Draw inner shield ''' gradient = QRadialGradient(QPointF(-128, -128), 384, QPointF(-128, -128)) gradient.setColorAt(0, QColor(255, 255, 255)) gradient.setColorAt(1, QColor(224, 224, 224)) painter.setBrush(gradient) painter.setPen(Qt.NoPen) painter.drawEllipse(QPoint(0, 0), 115, 115) painter.setPen(pen) painter.setBrush(Qt.black) painter.drawPoint(0, 0) line = 10 ''' Draw scale majorTicks using coords rotation ''' painter.save() painter.setBrush(Qt.black) painter.rotate(self.start_angle) # ''' initial angle (first tick) ''' painter.setBrush(QBrush(Qt.black)) t_rot = self.stop_angle / (self.minorTicks * (self.majorTicks - 1) + self.majorTicks - 1) for i in range( int((self.minorTicks) * (self.majorTicks - 1) + self.majorTicks)): if self.minorTicks: if (self.minorTicks + 1) == 0: painter.drawLine(QPoint(105, 0), QPoint(105 - line, 0)) else: painter.drawLine(QPoint(105, 0), QPoint(105 - line / 3, 0)) else: painter.drawLine(QPoint(105, 0), QPoint(105 - line, 0)) painter.rotate(t_rot) painter.restore() ''' Draw scale numbers using vector rotation ''' ''' x' = xcos(a)-ysin(a) ''' ''' y' = xsin(a)-ycos(a) ''' painter.save() rotation = (self.start_angle / 360) * 2 * pi # ''' Initial rotation ''' painter.setFont(self.digitFont) for i in range(int(self.majorTicks)): point = QPointF((70 * cos(rotation)), 70 * sin(rotation)) value = self.scaleFormat.format(self.wmin + i * self.step) size = painter.fontMetrics().size(Qt.TextSingleLine, value) point.setX(point.x() - size.width() / 2) # += int() point.setY(point.y() + size.height() / 4) painter.drawText(point, value) rotation += self.rot_rad painter.restore() labela = self.labelFormat.format(self.value) painter.setFont(self.labelFont) point = QPointF() size = painter.fontMetrics().size(Qt.TextSingleLine, labela) point.setX(point.x() - size.width() / 2) point.setY(point.y() + size.height() / 4 + self.labelOffset) painter.drawText(point, labela) if len(self.label) > 0: # Draw meter label painter.setFont(self.labelFont) point = QPointF() size = painter.fontMetrics().size(Qt.TextSingleLine, self.label) point.setX(point.x() - size.width() / 2) point.setY(point.y() + size.height() / 4 + self.labelOffset + 24) painter.drawText(point, self.label)
def setBackground(self): oImage = QImage('figure2.png') sImage = oImage.scaled(QSize(907, 690)) palette = QPalette() palette.setBrush(QPalette.Background, QBrush(sImage)) self.setPalette(palette)
def doHighlightBlock(self, text): """ Note: Never set the QTextBlockFormat for a QTextBlock from within the highlighter. Depending on how the block format is modified, a recursive call to the highlighter may be triggered, which will cause the application to crash. Likewise, don't try to set the QTextBlockFormat outside the highlighter (i.e., from within the text editor). While the application will not crash, the format change will be added to the undo stack. Attempting to undo from that point on will cause the undo stack to be virtually frozen, since undoing the format operation causes the text to be considered changed, thus triggering the slot that changes the text formatting to be triggered yet again. """ lastState = self.currentBlockState() # self.setFormat(0, len(text), self._defaultCharFormat) # Focus mode unfocus = self.unfocusConditions() if unfocus: fmt = self.format(0) fmt.setForeground(QBrush(self.defaultTextColor)) self.transparentFormat(fmt) if type(unfocus) != bool: start, end = unfocus self.setFormat(0, start, fmt) self.setFormat(end, len(text), fmt) else: self.setFormat(0, len(text), fmt) if self.tokenizer != None: self.tokenizer.clear() block = self.currentBlock() nextState = MS.MarkdownStateUnknown previousState = self.previousBlockState() if block.next().isValid(): nextState = block.next().userState() self.tokenizer.tokenize(text, lastState, previousState, nextState) self.setCurrentBlockState(self.tokenizer.getState()) self.inBlockquote = self.tokenizer.getState( ) == MS.MarkdownStateBlockquote # STATE FORMATTING # FIXME: generic if self.currentBlockState() in [ MS.MarkdownStatePipeTableHeader, MS.MarkdownStatePipeTableDivider, MS.MarkdownStatePipeTableRow ]: fmt = QTextCharFormat() f = fmt.font() f.setFamily("Monospace") fmt.setFont(f) self.setFormat(0, len(text), fmt) # Monospace the blank chars i = 0 while i <= len(text) - 1 and text[i] in [" ", "\t"]: fmt = self.format(i) fmt.setFontFamily("Monospace") self.setFormat(i, 1, fmt) i += 1 #if self.currentBlockState() == MS.MarkdownStateBlockquote: #fmt = QTextCharFormat(self._defaultCharFormat) #fmt.setForeground(Qt.lightGray) #self.setFormat(0, len(text), fmt) tokens = self.tokenizer.getTokens() for token in tokens: if token.type == MTT.TokenUnknown: qWarning( "Highlighter found unknown token type in text block.") continue if token.type in [ MTT.TokenAtxHeading1, MTT.TokenAtxHeading2, MTT.TokenAtxHeading3, MTT.TokenAtxHeading4, MTT.TokenAtxHeading5, MTT.TokenAtxHeading6, MTT.TokenSetextHeading1Line1, MTT.TokenSetextHeading2Line1, ]: self.storeHeadingData(token, text) self.applyFormattingForToken(token, text) if self.tokenizer.backtrackRequested(): previous = self.currentBlock().previous() self.highlightBlockAtPosition.emit(previous.position()) if self.spellCheckEnabled: self.spellCheck(text) # If the block has transitioned from previously being a heading to now # being a non-heading, signal that the position in the document no # longer contains a heading. if self.isHeadingBlockState(lastState) and \ not self.isHeadingBlockState(self.currentBlockState()): self.headingRemoved.emit(self.currentBlock().position())
def __init__(self, shape, pen=None, brush=None): self.shape = shape self.pen = pen or QPen() self.brush = brush or QBrush()
def add_io(self, vbox): if self.tx.locktime > 0: vbox.addWidget(QLabel("LockTime: %d\n" % self.tx.locktime)) vbox.addWidget(QLabel(_("Inputs") + ' (%d)' % len(self.tx.inputs()))) ext = QTextCharFormat() rec = QTextCharFormat() rec.setBackground(QBrush(ColorScheme.GREEN.as_color(background=True))) rec.setToolTip(_("Wallet receive address")) chg = QTextCharFormat() chg.setBackground(QBrush(ColorScheme.YELLOW.as_color(background=True))) chg.setToolTip(_("Wallet change address")) twofactor = QTextCharFormat() twofactor.setBackground( QBrush(ColorScheme.BLUE.as_color(background=True))) twofactor.setToolTip( _("TrustedCoin (2FA) fee for the next batch of transactions")) def text_format(addr): if self.wallet.is_mine(addr): return chg if self.wallet.is_change(addr) else rec elif self.wallet.is_billing_address(addr): return twofactor return ext def format_amount(amt): return self.main_window.format_amount(amt, whitespaces=True) i_text = QTextEditWithDefaultSize() i_text.setFont(QFont(MONOSPACE_FONT)) i_text.setReadOnly(True) cursor = i_text.textCursor() for x in self.tx.inputs(): if x['type'] == 'coinbase': cursor.insertText('coinbase') else: prevout_hash = x.get('prevout_hash') prevout_n = x.get('prevout_n') cursor.insertText(prevout_hash + ":%-4d " % prevout_n, ext) addr = self.wallet.get_txin_address(x) if addr is None: addr = '' cursor.insertText(addr, text_format(addr)) if x.get('value'): cursor.insertText(format_amount(x['value']), ext) cursor.insertBlock() vbox.addWidget(i_text) vbox.addWidget(QLabel(_("Outputs") + ' (%d)' % len(self.tx.outputs()))) o_text = QTextEditWithDefaultSize() o_text.setFont(QFont(MONOSPACE_FONT)) o_text.setReadOnly(True) cursor = o_text.textCursor() for o in self.tx.get_outputs_for_UI(): addr, v = o.address, o.value cursor.insertText(addr, text_format(addr)) if v is not None: cursor.insertText('\t', ext) cursor.insertText(format_amount(v), ext) cursor.insertBlock() vbox.addWidget(o_text)
class qt_drawings: """ Qt data used to draw tiles. """ tile_size = 10 tile_colors = [ QColor(235, 180, 40), QColor(255, 84, 46), QColor(68, 125, 255), QColor(83, 223, 56) ] tile_brushes = [[QBrush(tile_colors[0]), QBrush(tile_colors[1])], [QBrush(tile_colors[2]), QBrush(tile_colors[3])]] no_color = QColor(0, 0, 0, 0) no_pen = QPen(no_color) no_pen.setWidth(0) no_brush = QBrush(no_color) black_color = QColor(0, 0, 0) black_pen = QPen(black_color) black_brush = QBrush(black_color) cyan_color = QColor(30, 190, 220) cyan_brush = QBrush(cyan_color) gray_color = QColor(220, 220, 220, 80) gray_pen = QPen(gray_color) gray_brush = QBrush(gray_color) red_color = QColor(255, 40, 40) red_brush = QBrush(red_color) red_pen = QPen(red_color.darker(130)) cross_polygon = QPolygonF([ QPointF(1, 3), QPointF(3, 1), QPointF(tile_size / 2, 3), QPointF(tile_size - 3, 1), QPointF(tile_size - 1, 3), QPointF(tile_size - 3, tile_size / 2), QPointF(tile_size - 1, tile_size - 3), QPointF(tile_size - 3, tile_size - 1), QPointF(tile_size / 2, tile_size - 3), QPointF(3, tile_size - 1), QPointF(1, tile_size - 3), QPointF(3, tile_size / 2), ]) arrow_polygon = QPolygonF([ QPointF(2, 5), QPointF(tile_size / 2, 1), QPointF(tile_size - 2, 5), QPointF(tile_size / 2 + 1, 4), QPointF(tile_size / 2 + 1, tile_size - 1), QPointF(tile_size / 2 - 1, tile_size - 1), QPointF(tile_size / 2 - 1, 4), ]) @staticmethod def tile_to_brush(tile) -> QBrush: return qt_drawings.tile_brushes[tile.is_horizontal][tile.is_positive] @staticmethod def paint_tile(painter: QPainter, wx: int, wy: int, tile, tile_size: int): width = 2 * tile_size if tile.is_horizontal else tile_size height = tile_size if tile.is_horizontal else 2 * tile_size painter.fillRect(wx, wy, width, height, qt_drawings.tile_to_brush(tile)) if tile_size > 5: painter.drawRect(wx, wy, width, height)
def data(self, index: QModelIndex, role: Qt.ItemDataRole) -> QVariant: # note: this method is performance-critical. # it is called a lot, and so must run extremely fast. assert index.isValid() col = index.column() tx_item = self.transactions.value_from_pos(index.row()) is_lightning = tx_item.get('lightning', False) timestamp = tx_item['timestamp'] if is_lightning: status = 0 if timestamp is None: status_str = 'unconfirmed' else: status_str = format_time(int(timestamp)) else: tx_hash = tx_item['txid'] conf = tx_item['confirmations'] try: status, status_str = self.tx_status_cache[tx_hash] except KeyError: tx_mined_info = self.tx_mined_info_from_tx_item(tx_item) status, status_str = self.parent.wallet.get_tx_status(tx_hash, tx_mined_info) if role == Qt.UserRole: # for sorting d = { HistoryColumns.STATUS: # respect sort order of self.transactions (wallet.get_full_history) -index.row(), HistoryColumns.DESCRIPTION: tx_item['label'] if 'label' in tx_item else None, HistoryColumns.AMOUNT: (tx_item['bc_value'].value if 'bc_value' in tx_item else 0)\ + (tx_item['ln_value'].value if 'ln_value' in tx_item else 0), HistoryColumns.BALANCE: (tx_item['balance'].value if 'balance' in tx_item else 0), HistoryColumns.FIAT_VALUE: tx_item['fiat_value'].value if 'fiat_value' in tx_item else None, HistoryColumns.FIAT_ACQ_PRICE: tx_item['acquisition_price'].value if 'acquisition_price' in tx_item else None, HistoryColumns.FIAT_CAP_GAINS: tx_item['capital_gain'].value if 'capital_gain' in tx_item else None, HistoryColumns.TXID: tx_hash if not is_lightning else None, } return QVariant(d[col]) if role not in (Qt.DisplayRole, Qt.EditRole): if col == HistoryColumns.STATUS and role == Qt.DecorationRole: icon = "lightning" if is_lightning else TX_ICONS[status] return QVariant(read_QIcon(icon)) elif col == HistoryColumns.STATUS and role == Qt.ToolTipRole: if is_lightning: msg = 'lightning transaction' else: # on-chain if tx_item['height'] == TX_HEIGHT_LOCAL: # note: should we also explain double-spends? msg = _("This transaction is only available on your local machine.\n" "The currently connected server does not know about it.\n" "You can either broadcast it now, or simply remove it.") else: msg = str(conf) + _(" confirmation" + ("s" if conf != 1 else "")) return QVariant(msg) elif col > HistoryColumns.DESCRIPTION and role == Qt.TextAlignmentRole: return QVariant(Qt.AlignRight | Qt.AlignVCenter) elif col > HistoryColumns.DESCRIPTION and role == Qt.FontRole: monospace_font = QFont(MONOSPACE_FONT) return QVariant(monospace_font) #elif col == HistoryColumns.DESCRIPTION and role == Qt.DecorationRole and not is_lightning\ # and self.parent.wallet.invoices.paid.get(tx_hash): # return QVariant(read_QIcon("seal")) elif col in (HistoryColumns.DESCRIPTION, HistoryColumns.AMOUNT) \ and role == Qt.ForegroundRole and tx_item['value'].value < 0: red_brush = QBrush(QColor("#BC1E1E")) return QVariant(red_brush) elif col == HistoryColumns.FIAT_VALUE and role == Qt.ForegroundRole \ and not tx_item.get('fiat_default') and tx_item.get('fiat_value') is not None: blue_brush = QBrush(QColor("#1E1EFF")) return QVariant(blue_brush) return QVariant() if col == HistoryColumns.STATUS: return QVariant(status_str) elif col == HistoryColumns.DESCRIPTION and 'label' in tx_item: return QVariant(tx_item['label']) elif col == HistoryColumns.AMOUNT: bc_value = tx_item['bc_value'].value if 'bc_value' in tx_item else 0 ln_value = tx_item['ln_value'].value if 'ln_value' in tx_item else 0 value = bc_value + ln_value v_str = self.parent.format_amount(value, is_diff=True, whitespaces=True) return QVariant(v_str) elif col == HistoryColumns.BALANCE: balance = tx_item['balance'].value balance_str = self.parent.format_amount(balance, whitespaces=True) return QVariant(balance_str) elif col == HistoryColumns.FIAT_VALUE and 'fiat_value' in tx_item: value_str = self.parent.fx.format_fiat(tx_item['fiat_value'].value) return QVariant(value_str) elif col == HistoryColumns.FIAT_ACQ_PRICE and \ tx_item['value'].value < 0 and 'acquisition_price' in tx_item: # fixme: should use is_mine acq = tx_item['acquisition_price'].value return QVariant(self.parent.fx.format_fiat(acq)) elif col == HistoryColumns.FIAT_CAP_GAINS and 'capital_gain' in tx_item: cg = tx_item['capital_gain'].value return QVariant(self.parent.fx.format_fiat(cg)) elif col == HistoryColumns.TXID: return QVariant(tx_hash) if not is_lightning else QVariant('') return QVariant()
def refill(self, host): ''' popupates KPIs table to be connected to hostChanged signal (hostsTable) ''' if len(self.hosts) == 0: return if len(self.nkpis) == 0: log('[w] refill kips list is empty, return') return self.silentMode = True self.host = host #print('replace this by hType?') if self.hosts[host]['port'] == '': t = 'h' usedKPIs = self.hostKPIs else: t = 's' usedKPIs = self.srvcKPIs if t == 'h': kpiStyles = kpiStylesNN['host'] kpiList = self.hostKPIs else: kpiStyles = kpiStylesNN['service'] kpiList = self.srvcKPIs # go fill the table self.setRowCount(len(kpiList)) kpis = [ ] # list of kpi tuples in kpiDescription format (ones to be displayed depending on host/service + checkboxes #put enabled ones first: for kpin in self.nkpis[host]: kpis.append(kpin) #populate rest of KPIs (including groups): for kpi in kpiList: if kpi not in kpis: kpis.append(kpi) i = 0 #################################################################### #### ### ## ## ##### ######### ### ## ### ## ##### ### #### ## ## ###### ##### ######## ######## ##### # ### ##### ####### #### # # ## #### ## ## ######### ###### ###### #### ##### ##### #### ## ## ###### # # # ########### ##### ###### #### ##### ####### #### ### ## ## ### ######## ###### ###### #### ## ### #################################################################### self.kpiNames = [] # index for right mouse click events for kpiName in kpis: self.setRowHeight(i, 10) self.kpiNames.append(kpiName) # index for right mouse click events if kpiName[:1] != '.': #normal kpis cb = myCheckBox(host, kpiName) cb.setStyleSheet( "QCheckBox::indicator { width: 10px; height: 10px; margin-left:16px;}" ) if kpiName in self.nkpis[host]: cb.setChecked(True) ''' if kpiName not in kpiStyles: # it can disappear as a result of custom KPI reload log('%s not in the list of KPI styles, removing' % (kpiName)) continue ''' style = kpiStyles[kpiName] cb.stateChanged.connect(self.checkBoxChanged) self.setCellWidget(i, 0, cb) if 'style' in style: self.setCellWidget( i, 2, kpiCell(style['pen'], style['brush'], style['style'])) # customized styles else: self.setCellWidget(i, 2, kpiCell( style['pen'], )) # kpi pen style if 'disabled' in style.keys(): item = QTableWidgetItem(style['label']) item.setForeground(QBrush(QColor(255, 0, 0))) self.setItem(i, 1, item) # text name else: self.setItem(i, 1, QTableWidgetItem(style['label'])) # text name self.setItem(i, 9, QTableWidgetItem(style['desc'])) # descr grp = str(style['group']) if grp == '0': grp = '' self.setItem(i, 10, QTableWidgetItem(grp)) # group else: # kpi groups self.setCellWidget(i, 0, None) # no checkbox self.setCellWidget(i, 2, None) # no pen style self.setItem(i, 1, QTableWidgetItem(kpiName[1:])) # text name self.item(i, 1).setFont(QFont('SansSerif', 8, QFont.Bold)) self.setItem(i, 9, QTableWidgetItem()) # no desc self.setItem(i, 10, QTableWidgetItem()) # no group if kpiName in self.kpiScales[self.host].keys(): kpiScale = self.kpiScales[self.host][kpiName] self.setItem(i, 3, QTableWidgetItem(str( kpiScale['label']))) # Y-Scale self.setItem(i, 4, QTableWidgetItem(str(kpiScale['unit']))) self.setItem(i, 5, QTableWidgetItem(str(kpiScale['max_label']))) self.setItem(i, 8, QTableWidgetItem(str(kpiScale['last_label']))) else: #cleanup self.setItem(i, 3, QTableWidgetItem()) self.setItem(i, 4, QTableWidgetItem()) self.setItem(i, 5, QTableWidgetItem()) self.setItem(i, 8, QTableWidgetItem()) i += 1 self.silentMode = False return
def initUI(self): fuenteSiacle = self.font() fuenteSiacle.setBold(True) fuenteSiacle.setPointSize(12) # ================= FRAME PANEL DE CONTROL =================== paletaBotones = self.palette() paletaBotones.setColor(QPalette.Background, QColor("#2EFEC8")) frameBotones = QFrame() frameBotones.setFrameStyle(QFrame.NoFrame) frameBotones.setAutoFillBackground(True) frameBotones.setPalette(paletaBotones) frameBotones.setFixedWidth(220) # ============================================================ paletaPanel = self.palette() paletaPanel.setBrush(QPalette.Background, QBrush(QColor(255, 90, 0), Qt.SolidPattern)) paletaPanel.setColor(QPalette.Foreground, Qt.white) labelSiacle = QLabel("PANEL DE CONTROL", frameBotones) labelSiacle.setAlignment(Qt.AlignCenter | Qt.AlignVCenter) labelSiacle.setFont(fuenteSiacle) labelSiacle.setAutoFillBackground(True) labelSiacle.setPalette(paletaPanel) labelSiacle.setFixedSize(220, 46) labelSiacle.move(0, 0) # ============================================================ tamanioIcono = QSize(30, 30) botonNuevo = Boton(frameBotones) botonNuevo.setText(" Nuevo") botonNuevo.setToolTip("Nuevo cliente") botonNuevo.setCursor(Qt.PointingHandCursor) botonNuevo.move(-2, 45) botonActualizar = Boton(frameBotones) botonActualizar.setText(" Actualizar") botonActualizar.setToolTip("Actualizar cliente") botonActualizar.setCursor(Qt.PointingHandCursor) botonActualizar.move(-2, 82) botonEliminar = Boton(frameBotones) botonEliminar.setText(" Eliminar") botonEliminar.setToolTip("Eliminar cliente") botonEliminar.setCursor(Qt.PointingHandCursor) botonEliminar.move(-2, 119) botonLimpiar = Boton(frameBotones) botonLimpiar.setText(" Limpiar tabla") botonLimpiar.setToolTip("Limpiar tabla") botonLimpiar.setCursor(Qt.PointingHandCursor) botonLimpiar.move(-2, 156) # ============================================================ paletaSuscribete = self.palette() paletaSuscribete.setBrush( QPalette.Background, QBrush(QColor(135, 206, 250), Qt.SolidPattern)) fuenteSuscribete = self.font() fuenteSuscribete.setBold(True) fuenteSuscribete.setFamily("Arial") fuenteSuscribete.setPointSize(11) labelSuscribete = QLabel( "<a href='https://www.youtube.com/c/AndresNiñoPython?" "sub_confirmation=1'>SUSCRIBETE.</a>", frameBotones) labelSuscribete.setAlignment(Qt.AlignCenter | Qt.AlignVCenter) labelSuscribete.setOpenExternalLinks(True) labelSuscribete.setFont(fuenteSuscribete) labelSuscribete.setAutoFillBackground(True) labelSuscribete.setPalette(paletaSuscribete) labelSuscribete.setFixedSize(220, 46) labelSuscribete.move(0, 210) # ============ FRAME BIENVENIDO - CONFIGURACIÓN ============== paletaFrame = self.palette() paletaFrame.setColor(QPalette.Background, QColor("blue")) frameBienvenido = QFrame() frameBienvenido.setFrameStyle(QFrame.NoFrame) frameBienvenido.setAutoFillBackground(True) frameBienvenido.setPalette(paletaFrame) frameBienvenido.setFixedHeight(46) # ============================================================ paletaTitulo = self.palette() paletaTitulo.setColor(QPalette.Foreground, Qt.yellow) labelBienvenido = QLabel("BIENVENIDO A SIACLE") labelBienvenido.setAlignment(Qt.AlignCenter) labelBienvenido.setFont(fuenteSiacle) labelBienvenido.setPalette(paletaTitulo) botonConfiguracion = QPushButton() botonConfiguracion.setIcon(QIcon("Imagenes/configuracion.png")) botonConfiguracion.setIconSize(QSize(24, 24)) botonConfiguracion.setToolTip("Configurar Siacle") botonConfiguracion.setCursor(Qt.PointingHandCursor) botonConfiguracion.setFixedWidth(36) disenioFrame = QHBoxLayout() disenioFrame.addWidget(labelBienvenido, Qt.AlignCenter) disenioFrame.addStretch() disenioFrame.addWidget(botonConfiguracion) disenioFrame.setContentsMargins(0, 0, 5, 0) frameBienvenido.setLayout(disenioFrame) # ============================================================ self.buscarLineEdit = QLineEdit() self.buscarLineEdit.setObjectName("Enter") self.buscarLineEdit.setPlaceholderText("Nombre del cliente") self.buscarLineEdit.setMinimumSize(200, 26) botonBuscar = QPushButton("Buscar") botonBuscar.setObjectName("Buscar") botonBuscar.setCursor(Qt.PointingHandCursor) botonBuscar.setMinimumSize(60, 26) separadorTodos = QFrame() separadorTodos.setFrameShape(QFrame.VLine) separadorTodos.setFrameShadow(QFrame.Raised) separadorTodos.setFixedSize(1, 26) botonTodos = QPushButton("Todos") botonTodos.setObjectName("Todos") botonTodos.setCursor(Qt.PointingHandCursor) botonTodos.setMinimumSize(60, 26) nombreColumnas = ("Id", "Nombre", "Apellido", "Sexo", "Fecha de nacimiento", "País", "Teléfono o celular") menuMostrarOcultar = QMenu() for indice, columna in enumerate(nombreColumnas, start=0): accion = QAction(columna, menuMostrarOcultar) accion.setCheckable(True) accion.setChecked(True) accion.setData(indice) menuMostrarOcultar.addAction(accion) botonMostrarOcultar = QPushButton("Motrar/ocultar columnas") botonMostrarOcultar.setCursor(Qt.PointingHandCursor) botonMostrarOcultar.setMenu(menuMostrarOcultar) botonMostrarOcultar.setMinimumSize(180, 26) disenioBuscar = QHBoxLayout() disenioBuscar.setSpacing(10) disenioBuscar.addWidget(self.buscarLineEdit) disenioBuscar.addWidget(botonBuscar) disenioBuscar.addWidget(separadorTodos) disenioBuscar.addWidget(botonTodos) disenioBuscar.addWidget(botonMostrarOcultar) # =================== WIDGET QTableWidget =================== self.tabla = QTableWidget() # Deshabilitar edición self.tabla.setEditTriggers(QAbstractItemView.NoEditTriggers) # Deshabilitar el comportamiento de arrastrar y soltar self.tabla.setDragDropOverwriteMode(False) # Seleccionar toda la fila self.tabla.setSelectionBehavior(QAbstractItemView.SelectRows) # Seleccionar una fila a la vez self.tabla.setSelectionMode(QAbstractItemView.SingleSelection) # Especifica dónde deben aparecer los puntos suspensivos "..." cuando se muestran # textos que no encajan self.tabla.setTextElideMode(Qt.ElideRight) # Qt.ElideNone # Establecer el ajuste de palabras del texto self.tabla.setWordWrap(False) # Deshabilitar clasificación self.tabla.setSortingEnabled(False) # Establecer el número de columnas self.tabla.setColumnCount(7) # Establecer el número de filas self.tabla.setRowCount(0) # Alineación del texto del encabezado self.tabla.horizontalHeader().setDefaultAlignment(Qt.AlignHCenter | Qt.AlignVCenter | Qt.AlignCenter) # Deshabilitar resaltado del texto del encabezado al seleccionar una fila self.tabla.horizontalHeader().setHighlightSections(False) # Hacer que la última sección visible del encabezado ocupa todo el espacio disponible self.tabla.horizontalHeader().setStretchLastSection(True) # Ocultar encabezado vertical self.tabla.verticalHeader().setVisible(False) # Dibujar el fondo usando colores alternados self.tabla.setAlternatingRowColors(True) # Establecer altura de las filas self.tabla.verticalHeader().setDefaultSectionSize(20) # self.tabla.verticalHeader().setHighlightSections(True) # Establecer las etiquetas de encabezado horizontal usando etiquetas self.tabla.setHorizontalHeaderLabels(nombreColumnas) # Menú contextual self.tabla.setContextMenuPolicy(Qt.CustomContextMenu) self.tabla.customContextMenuRequested.connect(self.menuContextual) # Establecer ancho de las columnas for indice, ancho in enumerate((80, 240, 240, 140, 150, 130), start=0): self.tabla.setColumnWidth(indice, ancho) # ============================================================ disenioBuscarTabla = QVBoxLayout() disenioBuscarTabla.addLayout(disenioBuscar) disenioBuscarTabla.addWidget(self.tabla) disenioBuscarTabla.setSpacing(8) disenioBuscarTabla.setContentsMargins(10, 10, 10, 0) # ===================== LAYOUT DERECHO ======================= disenioDerecho = QVBoxLayout() disenioDerecho.addWidget(frameBienvenido) disenioDerecho.addLayout(disenioBuscarTabla) disenioDerecho.setContentsMargins(0, 0, 0, 0) # ====================== LAYOUT FINAL ====================== disenioFinal = QGridLayout() disenioFinal.addWidget(frameBotones, 0, 0) disenioFinal.addLayout(disenioDerecho, 0, 1) disenioFinal.setSpacing(0) disenioFinal.setContentsMargins(0, 0, 0, 0) self.setLayout(disenioFinal) # ========= GUARDAR INFORMACIÓN EN EL PORTAPAPELES ========= self.copiarInformacion = QApplication.clipboard() # ======================== EVENTOS ========================= botonNuevo.clicked.connect(self.Nuevo) botonActualizar.clicked.connect(self.Actualizar) botonEliminar.clicked.connect(self.Eliminar) botonLimpiar.clicked.connect(self.limpiarTabla) self.buscarLineEdit.returnPressed.connect(self.Buscar) botonBuscar.clicked.connect(self.Buscar) botonTodos.clicked.connect(self.Buscar) botonConfiguracion.clicked.connect(lambda: Configuracion(self).exec_()) self.tabla.itemDoubleClicked.connect(self.Suscribete) menuMostrarOcultar.triggered.connect(self.mostrarOcultar)
def showWedge(self, angle, color, extended=False, rev_gradient=False, outline_only=False): """Summary Args: angle (TYPE): Description color (TYPE): Description extended (bool, optional): Description rev_gradient (bool, optional): Description outline_only (bool, optional): Description """ # Hack to keep wedge in front # self.setRotation(self.pre_xover_item_group.rotation()) self._last_params = (angle, color, extended, rev_gradient, outline_only) radius = self._radius span = self.pre_xover_item_group.partCrossoverSpanAngle() / 2 radius_adjusted = radius + (_WEDGE_RECT_GAIN / 2) tip = QPointF(radius_adjusted, radius_adjusted) EXT = 1.35 if extended else 1.0 # print("wtf", tip, pos) base_p2 = QPointF(1, 1) line0 = QLineF(tip, QPointF(base_p2)) line1 = QLineF(tip, QPointF(base_p2)) line2 = QLineF(tip, QPointF(base_p2)) quad_scale = 1 + (.22 * (span - 5) / 55) # lo+(hi-lo)*(val-min)/(max-min) line0.setLength(radius_adjusted * EXT * quad_scale) # for quadTo control point line1.setLength(radius_adjusted * EXT) line2.setLength(radius_adjusted * EXT) line0.setAngle(angle) line1.setAngle(angle - span) line2.setAngle(angle + span) path = QPainterPath() if outline_only: self.setPen(getPenObj(color, 0.5, alpha=128, capstyle=Qt.RoundCap)) path.moveTo(line1.p2()) path.quadTo(line0.p2(), line2.p2()) else: gradient = QRadialGradient(tip, radius_adjusted * EXT) color1 = getColorObj(color, alpha=80) color2 = getColorObj(color, alpha=0) if rev_gradient: color1, color2 = color2, color1 if extended: gradient.setColorAt(0, color1) gradient.setColorAt(radius_adjusted / (radius_adjusted * EXT), color1) gradient.setColorAt( radius_adjusted / (radius_adjusted * EXT) + 0.01, color2) gradient.setColorAt(1, color2) else: gradient.setColorAt(0, getColorObj(color, alpha=50)) brush = QBrush(gradient) self.setBrush(brush) path.moveTo(line1.p1()) path.lineTo(line1.p2()) path.quadTo(line0.p2(), line2.p2()) path.lineTo(line2.p1()) self.setPath(path) self.show()
def make_candlestick(scene, n): width = 50 gap = 10 scene.addRect(QRectF((width + gap) * n, n, 100, 200), QPen(Qt.transparent), QBrush(Qt.green))
def refresh(self): if not self._mdlPlots or not self._mdlOutline or not self._mdlCharacter: return if not self.isVisible(): return LINE_HEIGHT = 18 SPACING = 3 TEXT_WIDTH = self.sldTxtSize.value() CIRCLE_WIDTH = 10 LEVEL_HEIGHT = 12 s = self.scene s.clear() # Get Max Level (max depth) root = self._mdlOutline.rootItem def maxLevel(item, level=0, max=0): if level > max: max = level for c in item.children(): m = maxLevel(c, level + 1) if m > max: max = m return max MAX_LEVEL = maxLevel(root) # Get the list of tracked items (array of references) trackedItems = [] if self.actPlots.isChecked(): trackedItems += self.plotReferences() if self.actCharacters.isChecked(): trackedItems += self.charactersReferences() ROWS_HEIGHT = len(trackedItems) * (LINE_HEIGHT + SPACING ) fm = QFontMetrics(s.font()) max_name = 0 for ref in trackedItems: name = references.title(ref) max_name = max(fm.width(name), max_name) TITLE_WIDTH = max_name + 2 * SPACING # Add Folders and Texts outline = OutlineRect(0, 0, 0, ROWS_HEIGHT + SPACING + MAX_LEVEL * LEVEL_HEIGHT) s.addItem(outline) outline.setPos(TITLE_WIDTH + SPACING, 0) refCircles = [] # a list of all references, to be added later on the lines # A Function to add a rect with centered elided text def addRectText(x, w, parent, text="", level=0, tooltip=""): deltaH = LEVEL_HEIGHT if level else 0 r = OutlineRect(0, 0, w, parent.rect().height()-deltaH, parent, title=text) r.setPos(x, deltaH) txt = QGraphicsSimpleTextItem(text, r) f = txt.font() f.setPointSize(8) fm = QFontMetricsF(f) elidedText = fm.elidedText(text, Qt.ElideMiddle, w) txt.setFont(f) txt.setText(elidedText) txt.setPos(r.boundingRect().center() - txt.boundingRect().center()) txt.setY(0) return r # A function to returns an item's width, by counting its children def itemWidth(item): if item.isFolder(): r = 0 for c in item.children(): r += itemWidth(c) return r or TEXT_WIDTH else: return TEXT_WIDTH def listItems(item, rect, level=0): delta = 0 for child in item.children(): w = itemWidth(child) if child.isFolder(): parent = addRectText(delta, w, rect, child.title(), level, tooltip=child.title()) parent.setToolTip(references.tooltip(references.textReference(child.ID()))) listItems(child, parent, level + 1) else: rectChild = addRectText(delta, TEXT_WIDTH, rect, "", level, tooltip=child.title()) rectChild.setToolTip(references.tooltip(references.textReference(child.ID()))) # Find tracked references in that scene (or parent folders) for ref in trackedItems: result = [] # Tests if POV scenePOV = False # Will hold true of character is POV of the current text, not containing folder if references.type(ref) == references.CharacterLetter: ID = references.ID(ref) c = child while c: if c.POV() == ID: result.append(c.ID()) if c == child: scenePOV = True c = c.parent() # Search in notes/references c = child while c: result += references.findReferencesTo(ref, c, recursive=False) c = c.parent() if result: ref2 = result[0] # Create a RefCircle with the reference c = RefCircle(TEXT_WIDTH / 2, - CIRCLE_WIDTH / 2, CIRCLE_WIDTH, ID=ref2, important=scenePOV) # Store it, with the position of that item, to display it on the line later on refCircles.append((ref, c, rect.mapToItem(outline, rectChild.pos()))) delta += w listItems(root, outline) OUTLINE_WIDTH = itemWidth(root) # Add Tracked items i = 0 itemsRect = s.addRect(0, 0, 0, 0) itemsRect.setPos(0, MAX_LEVEL * LEVEL_HEIGHT + SPACING) # Set of colors for plots (as long as they don't have their own colors) colors = [ "#D97777", "#AE5F8C", "#D9A377", "#FFC2C2", "#FFDEC2", "#D2A0BC", "#7B0F0F", "#7B400F", "#620C3D", "#AA3939", "#AA6C39", "#882D61", "#4C0000", "#4C2200", "#3D0022", ] for ref in trackedItems: if references.type(ref) == references.CharacterLetter: color = self._mdlCharacter.getCharacterByID(references.ID(ref)).color() else: color = QColor(colors[i % len(colors)]) # Rect r = QGraphicsRectItem(0, 0, TITLE_WIDTH, LINE_HEIGHT, itemsRect) r.setPen(QPen(Qt.NoPen)) r.setBrush(QBrush(color)) r.setPos(0, i * LINE_HEIGHT + i * SPACING) r.setToolTip(references.tooltip(ref)) i += 1 # Text name = references.title(ref) txt = QGraphicsSimpleTextItem(name, r) txt.setPos(r.boundingRect().center() - txt.boundingRect().center()) # Line line = PlotLine(0, 0, OUTLINE_WIDTH + SPACING, 0) line.setPos(TITLE_WIDTH, r.mapToScene(r.rect().center()).y()) s.addItem(line) line.setPen(QPen(color, 5)) line.setToolTip(references.tooltip(ref)) # We add the circles / references to text, on the line for ref2, circle, pos in refCircles: if ref2 == ref: circle.setParentItem(line) circle.setPos(pos.x(), 0) # self.view.fitInView(0, 0, TOTAL_WIDTH, i * LINE_HEIGHT, Qt.KeepAspectRatioByExpanding) # KeepAspectRatio self.view.setSceneRect(0, 0, 0, 0)
def paintGraph(self, graph, painter): brush = QBrush(Qt.SolidPattern) pen=QPen() brush.setColor(Qt.white) if(self.show_subgraphs): for node in graph.nodes: if type(node)==Graph: subgraph = node self.paintSubgraph(subgraph, painter, pen, brush) for edge in graph.edges: if("color" in edge.kwargs.keys()): pen.setColor(QColor(edge.kwargs["color"])) else: pen.setColor(QColor("black")) if("width" in edge.kwargs.keys()): pen.setWidth(int(edge.kwargs["width"])) else: pen.setWidth(1) painter.setPen(pen) painter.setBrush(brush) if(edge.source.parent_graph !=graph and not self.show_subgraphs): gspos = edge.source.parent_graph.global_pos else: gspos = edge.source.global_pos if(edge.dest.parent_graph !=graph and not self.show_subgraphs): gspos = edge.dest.parent_graph.global_pos else: gdpos = edge.dest.global_pos painter.drawLine(gspos[0],gspos[1], gdpos[0], gdpos[1]) # TODO : add more painting parameters for node in graph.nodes: if type(node)!=Graph: if("color" in node.kwargs.keys()): pen.setColor(QColor(node.kwargs["color"])) else: pen.setColor(QColor("black")) gpos = node.global_pos painter.setPen(pen) painter.setBrush(brush) if("shape" in node.kwargs.keys()): if(node.kwargs["shape"]=="box"): painter.drawRect( gpos[0]-node.size[0]/2, gpos[1]-node.size[1]/2, node.size[0], node.size[1]) if(node.kwargs["shape"]=="circle"): painter.drawEllipse( gpos[0]-node.size[0]/2, gpos[1]-node.size[1]/2, node.size[0], node.size[1]) else: painter.drawEllipse( gpos[0]-node.size[0]/2, gpos[1]-node.size[1]/2, node.size[0], node.size[1]) if("label" in node.kwargs.keys()): painter.drawText( gpos[0]-node.size[0]/2, gpos[1]-node.size[1]/2, node.size[0], node.size[1], Qt.AlignCenter|Qt.AlignTop,node.kwargs["label"]) else: if(self.show_subgraphs): self.paintGraph(subgraph, painter) else: subgraph = node self.paintSubgraph(subgraph, painter, pen, brush)
def paintEvent(self, *_): """ This is called on self.update() and on resize - makes resizes a bit ugly. This method draws every frame and forms the core of the program. """ painter = QPainter(self) painter.setRenderHint(QPainter.Antialiasing, True) painter.translate(self.width() / 2, self.height() / 2) # Make (0,0) centre if self.draw_axes: painter.setPen(QPen(QColor(0, 0, 0, 64), 1)) # Line(x1,y2,x2,y2) painter.drawLine( QLineF(0, self.height() / 2, 0, -self.height() / 2)) painter.drawLine(QLineF(self.width() / 2, 0, -self.width() / 2, 0)) colours = interpolate_hsv(self.col1, self.col2, self.num_dots - 2) # self.num_dots slider minimum is 2, so middle num minimum 0 which is ok last = None for cur_dot_num in range(self.num_dots): if self.join_end_dots: angle_off = radians(self.angle_factor / (self.num_dots - 1)) * cur_dot_num frame_no = self.frame_no + cur_dot_num * ( 180 / (self.num_dots - 1)) / self.speedmult else: angle_off = radians( self.angle_factor / self.num_dots) * cur_dot_num frame_no = self.frame_no + cur_dot_num * ( 180 / self.num_dots) / self.speedmult # green = (240/self.num_dots) * (self.num_dots - cur_dot_num) # blue = (240/self.num_dots) * cur_dot_num # colour = QColor(0, green, blue) colour = next(colours).toRgb() painter.setPen(QPen(colour)) painter.setBrush(QBrush(colour)) # progress = (cos(radians(SPEED_MULT * frame_no)) + 1)/2 * 180 progress = abs((frame_no * self.speedmult) % (2 * self.halfmax) - self.halfmax) # Progress oscillates every 360/speed_mult frames # Progress dictates the range of values of x later fed into cos(x) # frame_no multiplier dictates frequency of oscillations # Progress ranges between 0 and 180 which later gives us a # cos(progress) ranging between # 1 and -1, which combines with # sometimes-neg wid * hei to give a full range # print(self.frame_no,progress) height = sin(angle_off) * (self.height() - 100) width = cos(angle_off) * (self.width() - 100) # (0,0) is the centre x = cos(radians(self.x_multiplier * progress)) * width / 2 y = cos(radians(self.y_multiplier * progress)) * height / 2 if self.draw_lines: painter.setPen(QPen(colour, self.dot_size)) painter.drawLine(QPointF(x, y), QPointF(0, 0)) if self.connect_lines: if last: painter.drawLine(QPointF(x, y), last) last = QPointF(x, y) else: painter.drawEllipse(QPointF(x, y), self.dot_size, self.dot_size)
# -*- coding: utf-8 -*- ''' 【简介】 界面背景图片设置 ''' import sys from PyQt5.QtWidgets import QMainWindow, QApplication from PyQt5.QtGui import QPalette, QBrush, QPixmap app = QApplication(sys.argv) win = QMainWindow() win.setWindowTitle("界面背景图片设置") palette = QPalette() palette.setBrush(QPalette.Background, QBrush(QPixmap("./images/python.jpg"))) win.setPalette(palette) # 当背景图片的宽度和高度大于窗口的宽度和高度时 win.resize(460, 255) # 当背景图片的宽度和高度小于窗口的宽度和高度时 # win.resize(800, 600) win.show() sys.exit(app.exec_())
class ColorPanel(QGraphicsItem): """Summary Attributes: colordialog (TYPE): Description rect (TYPE): Description """ _shift_colors = [getColorObj(x) for x in styles.SCAF_COLORS] _colors = [getColorObj(x) for x in styles.STAP_COLORS] _PEN = Qt.NoPen def __init__(self, parent=None): """Summary Args: parent (None, optional): Description """ super(ColorPanel, self).__init__(parent) self.rect = QRectF(0, 0, 30, 30) self.setFlag(QGraphicsItem.ItemIgnoresTransformations) print( "A bug in Qt is about to cause a warning 'Layout still needs update after calling...'" ) print( "Please vote to fix here: https://bugreports.qt.io/browse/QTBUG-58699" ) self.colordialog = QColorDialog() self._shift_color_index = -1 # init on -1, painttool will cycle to 0 self._color_index = -1 # init on -1, painttool will cycle to 0 self._shift_color = self._shift_colors[self._shift_color_index] self._color = self._colors[self._color_index] self._shift_brush = QBrush(self._shift_color) self._brush = QBrush(self._color) self._initLabel() self.hide() def _initLabel(self): """Summary Returns: TYPE: Description """ self._label = label = QGraphicsTextItem("⇧", parent=self) label.setPos(28, -4) label.setFont(_FONT) def boundingRect(self): """Summary Returns: TYPE: Description """ return self.rect def paint(self, painter, option, widget=None): """Summary Args: painter (TYPE): Description option (TYPE): Description widget (None, optional): Description Returns: TYPE: Description """ painter.setPen(self._PEN) painter.setBrush(self._shift_brush) painter.drawRect(0, 0, 30, 15) painter.setBrush(self._brush) painter.drawRect(0, 15, 30, 15) def nextColor(self): """Summary Returns: TYPE: Description """ self._color_index += 1 if self._color_index == len(self._colors): self._color_index = 0 self._color = self._colors[self._color_index] self._brush.setColor(self._color) self.update() def prevColor(self): """Summary Returns: TYPE: Description """ self._color_index -= 1 def color(self): """Summary Returns: TYPE: Description """ return self._color def shiftColorName(self): """Summary Returns: TYPE: Description """ return self._shift_color.name() def colorName(self): """Summary Returns: TYPE: Description """ return self._color.name() def mousePressEvent(self, event): """Summary Args: event (QGraphicsSceneMouseEvent): Description Returns: TYPE: Description """ if event.pos().y() < 10: new_color = self.colordialog.getColor(self._shift_color) if new_color.isValid( ) and new_color.name() != self._shift_color.name(): self._shift_color = new_color self._shift_brush = QBrush(new_color) if new_color not in self._shift_colors: self._shift_colors.insert(self._shift_color_index, new_color) self.update() else: new_color = self.colordialog.getColor(self._color) if new_color.isValid() and new_color.name() != self._color.name(): self._color = new_color self._brush = QBrush(new_color) if new_color not in self._colors: self._colors.insert(self._color_index, new_color) self.update()
def initUI(self, path_to_options): """ initialize the view-scene graphic environment """ self.scene = QGraphicsScene() #self.scene.setSceneRect(0, 0, 640, 480) self.view = QGraphicsViewExtend(self.scene) self.view.setSceneRect(QRectF(self.view.viewport().rect())) self.view.setSceneRect(QRectF(0, 0, 850, 900)) self.view.setRenderHint(QPainter.Antialiasing) layout = QGridLayout() layout.addWidget(self.view) self.setLayout(layout) self.setBackgroundColor(QColor('green')) # special properties self.svgCardsPath = "../cards" self.cardsGraphItems = [] #holds all the cards items self.defInsertionPos = QPointF(0, 0) self.defAngle = 0 self.defScale = 0.5 self.deckBackSVG = 'back_1' self.numOfPlayers = 4 self.playersHandsPos = [(75, 50, 0), (210, 50, 180), (680, 50, 0), (210, 385, 0)] #(x,y,angle) self.defHandSpacing = 24 self.midCards = [] self.options_file_path = path_to_options # Card fields pen = QPen() brush = QBrush() self.scene.addRect(QRectF(200, 230, 100, 80), pen, brush) self.scene.addRect(QRectF(200 + 120, 230, 100, 80), pen, brush) self.scene.addRect(QRectF(200 + 120 * 2, 230, 100, 80), pen, brush) self.scene.addRect(QRectF(200 + 120 * 3, 230, 100, 80), pen, brush) # Player Names self.player1_label = self.addPlayerLabel(425, 350, "Player 1") self.player2_label = self.addPlayerLabel(0, 240, "Player 2") self.player3_label = self.addPlayerLabel(425, 20, "Player 3") self.player4_label = self.addPlayerLabel(782, 240, "Player 4") self.card1_label = self.addPlayerLabel(200, 210, "") self.card2_label = self.addPlayerLabel(200 + 120, 210, "") self.card3_label = self.addPlayerLabel(200 + 120 * 2, 210, "") self.card4_label = self.addPlayerLabel(200 + 120 * 3, 210, "") self.card_label_l = [ self.card1_label, self.card2_label, self.card3_label, self.card4_label ] self.card_label_pla = [ self.player1_label, self.player2_label, self.player3_label, self.player4_label ] self.play_1_state = self.addPlayerLabel(200, 250, "") self.play_2_state = self.addPlayerLabel(200 + 120, 250, "") self.play_3_state = self.addPlayerLabel(200 + 120 * 2, 250, "") self.play_4_state = self.addPlayerLabel(200 + 120 * 3, 250, "") self.game_indicator = self.addPlayerLabel(650, 5, "Game: ") self.mode_label = self.addPlayerLabel(150, 5, "Mode: ") playbtn = QPushButton('Start', self) playbtn.resize(50, 32) playbtn.move(10, 10) playbtn.clicked.connect(self.start_clicked) options = QPushButton('Options', self) options.resize(80, 32) options.move(65, 10) options.clicked.connect(self.options_clicked) nextRound = QPushButton('nextRound', self) nextRound.resize(80, 32) nextRound.move(150, 10) nextRound.setVisible(False) nextRound.clicked.connect(self.nextRound_clicked) self.scene.addWidget(playbtn) self.scene.addWidget(nextRound) self.scene.addWidget(options) self.my_game = None # Testing tree: self.my_tree = None # Storing game_play self.game_play = {} self.corrString = "" # emit signal: self.server_receivedSig.connect(self.parseClient) ### Client stuff: self.clientTimer = QTimer(self) self.tcpSocket = None self.games_played = 0 self.reset_client() self.server_thread = None
def general_window(self): ''' Assert of Web-connection ''' try: self.pre_start_program() except: self.message_box() ''' Creating menu, basic widgets, buttons and labels ''' menubar = self.menuBar() opt_ns_Menu = menubar.addMenu('&Опции') self.get_Action = QAction('&Начать', self) self.get_Action.setShortcut('Ctrl+r') exit_Action = QAction('&Выход', self) exit_Action.setShortcut('Ctrl+Q') self.get_Action.triggered.connect(self.start_program) exit_Action.triggered.connect(self.close) opt_ns_Menu.addAction(self.get_Action) opt_ns_Menu.addAction(exit_Action) try_Menu = menubar.addMenu('&Учебник') try_Action = QAction('&Правила к заданиям', self) try_Action.triggered.connect(self.buttom_browser) try_Menu.addAction(try_Action) dop_Menu = menubar.addMenu('&Дополнительно') to_addAction_1 = QAction('&О разработчиках', self) to_addAction_2 = QAction('&Почему Паланик?', self) info_PyQt5 = lambda: QMessageBox.aboutQt(self) to_addAction_1.triggered.connect(info_PyQt5) to_addAction_2.triggered.connect(self.button_palanuk) dop_Menu.addAction(to_addAction_1) dop_Menu.addAction(to_addAction_2) self.setStatusTip('Строка состояния') self.get_Action.setStatusTip('Начать тест') exit_Action.setStatusTip('Выход из программы') try_Action.setStatusTip('Необходимый атрибут') to_addAction_1.setStatusTip('Важная информация') to_addAction_2.setStatusTip('Причём тут Чак Паланик?') ''' Window space ''' self.image_background(self, 910, 600) back_map = QImage("image_back_1.jpg") back_map_2 = back_map.scaled(QSize(910, 600)) palette = QPalette() palette.setBrush(QPalette.Window, QBrush(back_map_2)) self.setPalette(palette) lbl_1 = QLabel('Заполните недостающие формы неправильных глаголов', self) lbl_1.setFont(QtGui.QFont("Times", 14, QtGui.QFont.Bold)) lbl_1.adjustSize() lbl_1.move(180, 50) self.textEdit = QTextEdit() self.statusBar() self.pbar = QProgressBar(self) self.pbar.setGeometry(350, 100, 200, 25) self.timer = QBasicTimer() self.step = 0 btn_1 = QLabel('Первая ->', self) btn_1.move(60, 148) self.line_1 = QLabel(self) self.line_1.move(153, 151) self.line_1_2 = QLabel(self) self.line_1_2.move(153, 200) btn_2 = QLabel('Вторая ->', self) btn_2.move(260, 150) self.line_2 = QLineEdit(self) self.line_2.setMaxLength(14) self.line_2.setFixedSize(108, 33) self.line_2.move(350, 150) self.line_2_2 = QLabel(self) self.line_2_2.move(353, 200) btn_3 = QLabel('Третья ->', self) btn_3.move(460, 150) self.line_3 = QLineEdit(self) self.line_3.setMaxLength(14) self.line_3.setFixedSize(108, 33) self.line_3.move(540, 150) self.line_3_2 = QLabel(self) self.line_3_2.move(543, 200) btn_t = QLabel('Перевод ->', self) btn_t.move(655, 150) self.line_t = QLineEdit(self) self.line_t.setMaxLength(14) self.line_t.setFixedSize(108, 33) self.line_t.move(750, 150) self.line_t_2 = QLabel(self) self.line_t_2.move(753, 200) self.draw_fonts( self.line_1_2, self.line_1, self.line_2, self.line_2_2, self.line_3, self.line_3_2, self.line_t, self.line_t_2, ) pix_map = QPixmap("images.jpeg") img = QLabel(self) img.setPixmap(pix_map) img.setGeometry(60, 270, 225, 225) lbl_img = QLabel('Это - Чак Паланик', self) lbl_img.setFont(QtGui.QFont("Times", 14, QtGui.QFont.Bold)) lbl_img.adjustSize() lbl_img.move(60, 520) img.setStatusTip('Чак Паланик') self.choice_verbs() self.lbl_limit = QLabel(self) self.lbl_limit.setFont(QtGui.QFont('Times', 20, QtGui.QFont.Bold)) self.lbl_limit.move(400, 295) self.lbl_lim_set_stat = QLabel('Cтaрт: Ctrl+r', self) self.lbl_lim_set_stat.setFont( QtGui.QFont('Times', 12, QtGui.QFont.Bold)) self.lbl_lim_set_stat.adjustSize() self.lbl_lim_set_stat.move(380, 370) self.true_limit = QLabel('Правильных ответов:', self) self.true_limit.setFont(QtGui.QFont('Times', 14, QtGui.QFont.Bold)) self.true_limit.adjustSize() self.true_limit.move(620, 280) self.true_limit_2 = QLabel(self) self.true_limit_2.setFont(QtGui.QFont('Times', 18, QtGui.QFont.Bold)) self.true_limit_2.adjustSize() self.true_limit_2.move(700, 320) self.btn_back = QPushButton('Назад', self) self.btn_back.resize(self.btn_back.sizeHint()) self.btn_back.clicked.connect(self.back_value) self.btn_back.setGeometry(350, 440, 200, 25) self.btn_back.blockSignals(True) self.btn_assert = QPushButton('Проверить', self) self.btn_assert.resize(self.btn_assert.sizeHint()) self.btn_assert.clicked.connect(self.show_verbs) self.btn_assert.setGeometry(490, 480, 200, 25) self.btn_assert.blockSignals(True) lbl_assert = QLabel( 'Если вы не заполнили пропуски,\n' 'то при нажатии этих клавиш\n' 'вы не сможете изменить ответ.', self) lbl_assert.adjustSize() lbl_assert.move(490, 510) self.btn_next = QPushButton('Далее', self) self.btn_next.resize(self.btn_assert.sizeHint()) self.btn_next.setFocus() self.btn_next.setAutoDefault(True) self.btn_next.clicked.connect(self.next_value) self.btn_next.setGeometry(650, 440, 200, 25) self.btn_next.blockSignals(True) self.lbl_next = QLabel(self) self.lbl_next.move(730, 480) self.show()
def initUI(self, id): self.setWindowTitle('结果查看') self.setWindowIcon(QIcon('./images/icon.jpg')) self.setGeometry(10, 10, 900, 800) # self.setMaximumSize() self.setWindowFlags(Qt.Qt.SubWindow) self.taskid = id grid = QGridLayout() closeBtn = QPushButton('关闭') downloadReportBtn = QPushButton('下载报告') downloadLogBtn = QPushButton('下载日志') closeBtn.resize(closeBtn.sizeHint()) closeBtn.clicked.connect(self.close) downloadReportBtn.resize(downloadReportBtn.sizeHint()) downloadReportBtn.clicked.connect(self.downloadReport) downloadLogBtn.resize(downloadLogBtn.sizeHint()) downloadLogBtn.clicked.connect(self.downloadLog) self.tipLabel = QLabel() # self.tipLabel.(QColor(20,150,150)) self.tipLabel.setFont(QFont('sanserif', 12)) self.tipLabel.setText('') self.errMsgLabel = QLabel() self.errMsgLabel.setFont(QFont('sanserif', 16)) self.errMsgLabel.setText('') self.pe_red = QPalette() self.pe_red.setColor(QPalette.WindowText, Qt.Qt.red) self.errMsgLabel.setPalette(self.pe_red) self.tree = QTreeWidget() self.tree.setColumnCount(1) self.tree.setHeaderLabels(['']) self.tree.setColumnWidth(0, 750) self.featureTree = QTreeWidgetItem() grid.addWidget(closeBtn, 1, 9) grid.addWidget(downloadReportBtn, 1, 10) # grid.addWidget(downloadLogBtn, 1, 10) # 日志下载暂时停用 grid.addWidget(self.tipLabel, 2, 0, 1, 5) grid.addWidget(self.errMsgLabel, 2, 5, 1, 3) grid.addWidget(self.tree, 3, 0, 20, 11) self.setLayout(grid) self.show() cf = getter.get_app_conf() projectPath = str(cf.get('baseconf', 'projectLocation')) reportPath = os.path.join(projectPath, 'reports', str(id), 'report.log') # 获取结果 数据库查询 res = getter.get_task_his_by_id(self.taskid) result = res['result'] if len(result) == 0: self.errMsgLabel.setText('没有生成报告,请确定是否执行结束') return step_flag = None scen_flag = None total_cnt = 0 failed_cnt = 0 for f in result.split('\n'): if f.strip().startswith('场景:'): total_cnt += 1 step_flag = True scen_flag = True self.featureTree = QTreeWidgetItem(self.tree) self.featureTree.setText(0, f.strip()[len('场景:'):].strip()) elif not f.strip().startswith('背景:') and not f.strip().startswith('功能:') and not f.strip() == '': backgroundTree = QTreeWidgetItem(self.featureTree) if '...' in f: backgroundTree.setText(0, f.replace('\n', '')[: f.index('...')]) else: backgroundTree.setText(0, f.replace('\n', '')) if 'passed' in f: # backgroundTree.setBackground(0, QBrush(QColor(0, 250, 0))) step_flag = True if 'failed' in f: backgroundTree.setForeground(0, QBrush(QColor(250, 0, 0))) step_flag = False scen_flag = False failed_cnt += 1 if step_flag: pass # backgroundTree.setBackground(0, QBrush(QColor(0, 250, 0))) else: # backgroundTree.setBackground(0, QBrush(QColor(250, 0, 0))) backgroundTree.setForeground(0, QBrush(QColor(250, 0, 0))) if scen_flag: self.featureTree.setForeground(0, QBrush(QColor(0, 250, 0))) else: self.featureTree.setForeground(0, QBrush(QColor(255, 0, 0))) # file.close() self.tipLabel.setText('全部用例:' + str(total_cnt) + '条, 通过用例:' + str(total_cnt - failed_cnt) + '条, 失败用例:' + str(failed_cnt) + '条')
import time from cadnano.gui.views import styles import cadnano.util as util from PyQt5.QtCore import QPointF, QRectF, Qt, QEvent from PyQt5.QtGui import QBrush, QFont, QFontMetrics, QPen, QColor, QPainterPath, QPolygonF from PyQt5.QtWidgets import QGraphicsItem, QGraphicsPathItem, QGraphicsRectItem, QGraphicsSimpleTextItem _BASE_WIDTH = styles.PATH_BASE_WIDTH _toHelixNumFont = styles.XOVER_LABEL_FONT # precalculate the height of a number font. Assumes a fixed font # and that only numbers will be used for labels _FM = QFontMetrics(_toHelixNumFont) _ENAB_BRUSH = QBrush(Qt.SolidPattern) # Also for the helix number label _NO_BRUSH = QBrush(Qt.NoBrush) # _RECT = QRectF(0, 0, baseWidth, baseWidth) _X_SCALE = styles.PATH_XOVER_LINE_SCALE_X # control point x constant _Y_SCALE = styles.PATH_XOVER_LINE_SCALE_Y # control point y constant _RECT = QRectF(0, 0, _BASE_WIDTH, _BASE_WIDTH) class XoverNode3(QGraphicsRectItem): """ This is a QGraphicsRectItem to allow actions and also a QGraphicsSimpleTextItem to allow a label to be drawn """ def __init__(self, virtual_helix_item, xover_item, strand3p, idx): super(XoverNode3, self).__init__(virtual_helix_item) self._vhi = virtual_helix_item
def paintEvent(self, event): qp = QPainter(self) qp.setRenderHint( QPainter.Antialiasing ) # <- Set anti-aliasing See https://wiki.python.org/moin/PyQt/Painting%20and%20clipping%20demonstration size = self.size() widget_width, widget_height = size.width(), size.height() # Make fonts time_label_font = qp.font() time_label_font.setPointSize(self.time_label_font_size) task_label_font = qp.font() task_label_font.setPointSize(self.task_label_font_size) # Frame qp.setPen(QPen(Qt.black, self.border_size, Qt.SolidLine)) qp.setBrush(QBrush(Qt.white, Qt.SolidPattern)) qp.drawRect( self.margin_size + self.time_label_margin, # x_start self.margin_size, # y_start widget_width - 2 * self.margin_size - self.time_label_margin, # x_size widget_height - 2 * self.margin_size) # y_size ## Starting time label #qp.setFont(time_label_font) #qp.drawText(0, #self.margin_size, # x_start # self.margin_size - int(self.time_label_font_size/2), # y_start # self.time_label_margin, # x_size # self.time_label_font_size, # y_size # Qt.AlignCenter, # self.starting_time_str) ## Ending time label #qp.setFont(time_label_font) #qp.drawText(0, #self.margin_size, # x_start # widget_height - self.margin_size - int(self.time_label_font_size/2), # y_start # self.time_label_margin, # x_size # self.time_label_font_size, # y_size # Qt.AlignCenter, # self.ending_time_str) # Draw a line for each hour qp.setPen(QPen(Qt.gray, 1, Qt.SolidLine)) qp.setFont(time_label_font) if self.starting_time.minute == 0: i = 0 else: i = 1 marker_time = datetime.datetime(year=self.starting_time.year, month=self.starting_time.month, day=self.starting_time.day, hour=self.starting_time.hour + i) while marker_time.hour <= self.ending_time.hour: time_marker_str = marker_time.strftime("%H:%M") marker_time_y_pos = self.timeCoordinateMapper(time_marker_str) qp.drawLine( self.margin_size + self.time_label_margin, # x_start marker_time_y_pos, # y_start widget_width - self.margin_size, # x_end marker_time_y_pos) # y_end qp.drawText( 0, #self.margin_size, # x_start marker_time_y_pos - int(self.time_label_font_size / 2), # y_start self.time_label_margin, # x_size self.time_label_font_size, # y_size Qt.AlignCenter, time_marker_str) if marker_time.hour == 23: break i += 1 marker_time = datetime.datetime(year=self.starting_time.year, month=self.starting_time.month, day=self.starting_time.day, hour=self.starting_time.hour + i) # Tasks qp.setPen(QPen(Qt.black, self.border_size, Qt.SolidLine)) #qp.setBrush(QBrush(Qt.yellow, Qt.SolidPattern)) #qp.setBrush(QBrush(QColor("#fcaf3e88"), Qt.SolidPattern)) qp.setBrush(QBrush(QColor(194, 135, 0, 128), Qt.SolidPattern)) qp.setFont(task_label_font) for task in self.data: y_start = self.timeCoordinateMapper(task["start"]) y_end = self.timeCoordinateMapper(task["end"]) qp.drawRect( self.margin_size + self.time_label_margin, # x_start y_start, # y_start widget_width - 2 * self.margin_size - self.time_label_margin, # x_size y_end - y_start) # y_size qp.drawText( self.margin_size + self.time_label_margin, # x_start y_start, # y_start widget_width - 2 * self.margin_size - self.time_label_margin, # x_size y_end - y_start, # y_size Qt.AlignCenter, task["label"]) # Draw a line to show the current time current_time_str = datetime.datetime.now().strftime("%H:%M") current_time_y_pos = self.timeCoordinateMapper(current_time_str) qp.setPen(QPen(Qt.red, self.border_size, Qt.SolidLine)) qp.setBrush(QBrush(Qt.red, Qt.SolidPattern)) qp.drawLine( self.margin_size + self.time_label_margin, # x_start current_time_y_pos, # y_start widget_width - self.margin_size, # x_end current_time_y_pos) # y_end # Current time bullet bullet_border = 5 qp.setPen(QPen(Qt.red, bullet_border, Qt.SolidLine)) qp.setBrush(QBrush(Qt.red, Qt.SolidPattern)) qp.setRenderHint( QPainter.Antialiasing ) # <- Set anti-aliasing See https://wiki.python.org/moin/PyQt/Painting%20and%20clipping%20demonstration bullet_radius = 3 qp.drawEllipse( self.margin_size + self.time_label_margin - bullet_radius, # x_start, current_time_y_pos - bullet_radius, # y_start, 2 * bullet_radius, 2 * bullet_radius)
def __init__(self): super().__init__() self.setupUi(self) ''' initCards : 랜덤으로 줘야 해 - 서버에서 해서 뿌려야 할 것 같음. 진영 용택 논의 필요 clientIndex : 서버에서 받아야 함 beginnerIndex : 서버에서 받아야 함 ''' self.beginnerIndex = 0 self.clientIndex = 0 self.isTurn = 1 self.gm = GM(initCards(5), self.clientIndex, self.beginnerIndex) self.gm.distributeCards() self.btnGiveHint.clicked.connect(self.clickedGiveHint) # 배경 사진 넣기 background = QImage("background.jpeg") palette = QPalette() palette.setBrush(10, QBrush(background)) self.setPalette(palette) self.notice.setText(" ") self.remainDeck.setText("남은 카드 \n%d" % len(self.gm.cards)) # 임의 부여함. # 들고 있는 카드의 list self.deckList = [[self.player0Deck0, self.player0Deck1, self.player0Deck2, self.player0Deck3], [self.player1Deck0, self.player1Deck1, self.player1Deck2, self.player1Deck3], [self.player2Deck0, self.player2Deck1, self.player2Deck2, self.player2Deck3], [self.player3Deck0, self.player3Deck1, self.player3Deck2, self.player3Deck3]] # 낸 카드의 list self.drpoedCardList = [self.playedRed, self.playedGreen, self.playedBlue, self.playedWhite, self.playedYellow] # 버린 카드의 list self.thrownCardList = [[self.throwR1, self.throwR2, self.throwR3, self.throwR4, self.throwR5], [self.throwG1, self.throwG2, self.throwG3, self.throwG4, self.throwG5], [self.throwB1, self.throwB2, self.throwB3, self.throwB4, self.throwB5], [self.throwW1, self.throwW2, self.throwW3, self.throwW4, self.throwW5], [self.throwY1, self.throwY2, self.throwY3, self.throwY4, self.throwY5]] # 힌트 토큰의 list self.hintTokenList = [self.hintToken0, self.hintToken1, self.hintToken2, self.hintToken3, self.hintToken4, self.hintToken5, self.hintToken6, self.hintToken7] # 목숨 토큰의 list self.lifeTokenList = [self.lifeToken0, self.lifeToken1, self.lifeToken2] for card in self.drpoedCardList: card.setText("0") print(type(self.player3Deck2)) for deck in self.gm.playerDecks: print(deck) for i, deck in enumerate(self.deckList): # clinet 위치를 어떻게 잡느냐가 관건.. # 아래 주석은 자신의 카드를 가리기 위한 코드. test 시에는 무시하고 진행한다. ''' if i == self.clientIndex: for j in range(4): SetCardDesign("mine", deck[j]) ''' for j in range(4): SetCardDesign(self.gm.playerDecks[i].getCardOrNone(j).getColor(), deck[j]) deck[j].setText(str(self.gm.playerDecks[i].getCardOrNone(j))) self.btnThrow.clicked.connect(self.ShowThrowDeck) self.btnDrop.clicked.connect(self.ShowDropDeck) self.btnGiveHint.clicked.connect(self.ShowGiveHint) # 다음 내용은 불변. # 창 아이콘 self.setWindowIcon(QIcon('Hanabi.PNG')) # 창크기 조절, 출력 self.setFixedSize(1910, 990) self.setWindowTitle('Hanabi') self.show()