lines = f.read().split("\n") res = [] while lines[-1] == '': lines.pop() for i in lines: u, v = map(float, i.split()) res.append([u, v]) self.data = res if __name__ == '__main__': app = QApplication(sys.argv) app.setStyle("Fusion") palette = QPalette() palette.setColor(QPalette.Window, QColor(53, 53, 53)) palette.setColor(QPalette.WindowText, Qt.white) palette.setColor(QPalette.Base, QColor(25, 25, 25)) palette.setColor(QPalette.AlternateBase, QColor(53, 53, 53)) palette.setColor(QPalette.ToolTipBase, Qt.white) palette.setColor(QPalette.ToolTipText, Qt.white) palette.setColor(QPalette.Text, Qt.white) palette.setColor(QPalette.Button, QColor(53, 53, 53)) palette.setColor(QPalette.ButtonText, Qt.white) palette.setColor(QPalette.BrightText, Qt.red) palette.setColor(QPalette.Link, QColor(42, 130, 218)) palette.setColor(QPalette.Highlight, QColor(42, 130, 218)) palette.setColor(QPalette.HighlightedText, Qt.black) app.setPalette(palette) view = Window() view.show()
def initUI(self): self.setGeometry(self.xPos, self.yPos, self.width, self.height) self.setFixedSize(self.width, self.height) self.setWindowTitle("Hachiko's Journal") windowBG = "rgb(0, 0, 77)" selectedColor = "rgb(0, 0, 179)" self.setStyleSheet(f"background-color: {windowBG}; font-size: 15px;") colorBG = "rgb(152, 208, 245)" self.tabWidget = QTabWidget() self.tabWidget.setStyleSheet(f"QTabBar::tab:selected {{color: white; background-color: {colorBG};}};") self.journalTab = QWidget() self.journalTab.setStyleSheet(f"background-color: {colorBG};") self.memoriesTab = QWidget() self.memoriesTab.setStyleSheet(f"background-color: {colorBG};") self.journalLayout = QGridLayout() self.journalEdit = QTextEdit() journalFont = QFont("Century Gothic") self.journalEdit.setFont(journalFont) self.journalEdit.setStyleSheet("background-image: url(img/linedpaper.png); background-repeat: no-repeat; background-position: center; font-size: 24px;") self.journalEdit.setText("Dear Hachiko,\n\n") self.journalLayout.addWidget(self.journalEdit, 0, 0, 1, 4) self.speechLabel = QLabel() self.speechLabel.setText("\t Hi! I'm Hachiko!") self.speechLabel.setStyleSheet("background-image: url(img/speechbubble.png); background-repeat: no-repeat; font-size: 20px;") self.journalLayout.addWidget(self.speechLabel, 1, 0, 1, 3) self.hachikoLabel = QLabel() self.hachikoMovie = QMovie("img/HachikoHappyGif") self.hachikoLabel.setMovie(self.hachikoMovie) self.hachikoMovie.start() self.journalLayout.addWidget(self.hachikoLabel, 1, 3) self.saveButton = SharpButton(primaryColor = windowBG, secondaryColor = colorBG) self.saveButton.setText("Save Journal") self.saveButton.clicked.connect(self.save) self.journalLayout.addWidget(self.saveButton, 2, 0) self.wagButton = SharpButton(primaryColor = windowBG, secondaryColor = colorBG) self.wagButton.setText("Wag tail!") self.wagButton.clicked.connect(self.wag) self.journalLayout.addWidget(self.wagButton, 2, 1) self.howlButton = SharpButton(primaryColor = windowBG, secondaryColor = colorBG) self.howlButton.setText("Howl!") self.howlButton.clicked.connect(self.howl) self.journalLayout.addWidget(self.howlButton, 2, 2) self.headTiltButton = SharpButton(primaryColor = windowBG, secondaryColor = colorBG) self.headTiltButton.setText("Do a head tilt!") self.headTiltButton.clicked.connect(self.tilt) self.journalLayout.addWidget(self.headTiltButton, 2, 3) self.journalTab.setLayout(self.journalLayout) self.tabWidget.addTab(self.journalTab, "Journal") self.tabWidget.addTab(self.memoriesTab, "Memories") self.setCentralWidget(self.tabWidget) self.memoriesLayout = QGridLayout() self.journalsListLabel = QLabel() self.journalsListLabel.setText("Past Journals") self.memoriesLayout.addWidget(self.journalsListLabel, 0, 0, 1, 1) self.openButton = SharpButton(primaryColor = windowBG, secondaryColor = colorBG) self.openButton.setText("Open Journal") self.openButton.clicked.connect(self.open) self.memoriesLayout.addWidget(self.openButton, 0, 3, 1, 1) self.journalsList = QListWidget() self.journalsList.setStyleSheet(f"color: rgb(193, 193, 240); background-color: rgb(0, 13, 51); selection-color: rgb(0, 13, 51); selection-background-color: rgb(193, 193, 240)") for journal in os.listdir("journals/"): item = QListWidgetItem(journal) if journal[-6] == "1": item.setBackground(QColor(57, 172, 57)) self.journalsList.addItem(item) self.memoriesLayout.addWidget(self.journalsList, 1, 0, 1, 4) self.memoriesTab.setLayout(self.memoriesLayout) self.sentThread.start() self.show()
def paintEvent(self, event): qp = QPainter() qp.begin(self) # Drawing Background qp.setOpacity(0.5) qp.setBrush(QColor(185, 151, 91)) qp.drawRect(0, 0, 1000, 650) qp.setOpacity(1) # Drawing Leaderboard qp.setFont(QFont("Arial", 36)) qp.setPen(QPen(Qt.black, 40)) qp.drawText(650, 90, "Leaderboard") qp.setFont(QFont("Arial", 18)) qp.drawText(628, 135, "Rank") qp.drawText(728, 135, "Name") qp.drawText(825, 135, "Moves") lead_dict = {} lead_keys = [] lead_vals = [] with open('leaderboard.txt', 'r') as leaderboard: for line in leaderboard: # print(line) line = line.split() lead_dict[line[0]] = line[1] # print(lead_dict) for key in lead_dict.keys(): lead_keys.append(key) for val in lead_dict.values(): lead_vals.append(val) # print(lead_keys) # print(lead_vals) for r in range(LEAD_ROW): for c in range(LEAD_COL): if r%2 == 0: qp.setBrush(QColor(17, 87, 64)) # Green else: qp.setBrush(QColor(185, 151, 91)) # Gold qp.setFont(QFont("Arial", 16)) qp.setPen(QPen(Qt.black, 2)) qp.drawRect(LEAD_ORIGINX+c*LEAD_WIDTH, LEAD_ORIGINY+r*LEAD_HEIGHT, LEAD_WIDTH, LEAD_HEIGHT) if r%2 == 0: qp.setPen(QColor(185, 151, 91)) # Gold qp.setBrush(QColor(17, 87, 64)) # Green else: qp.setPen(QColor(17, 87, 64)) qp.setBrush(QColor(185, 151, 91)) if c == 0: qp.drawText(LEAD_ORIGINX+c*LEAD_WIDTH+(LEAD_WIDTH//2.2), LEAD_ORIGINY+r*LEAD_HEIGHT+(LEAD_HEIGHT//2), \ str(rank[r])) elif c == 1: qp.drawText(LEAD_ORIGINX+c*LEAD_WIDTH+(LEAD_WIDTH//3), LEAD_ORIGINY+r*LEAD_HEIGHT+(LEAD_HEIGHT//2), \ lead_keys[r]) else: qp.drawText(LEAD_ORIGINX+c*LEAD_WIDTH+(LEAD_WIDTH//2.5), LEAD_ORIGINY+r*LEAD_HEIGHT+(LEAD_HEIGHT//2), \ lead_vals[r]) # Drawing Board for row in range(CELL_COUNT): for col in range(CELL_COUNT): if self.__board[row][col] != '': qp.setBrush(QColor(17, 87, 64)) qp.setPen(QPen(Qt.black, 2)) qp.drawRect(GRID_ORIGINX+col*CELL_SIZE, GRID_ORIGINY+row*CELL_SIZE, CELL_SIZE, CELL_SIZE) if len(str(self.__board[row][col])) < 2: qp.setFont(QFont("Arial", 20)) qp.setPen(QColor(185, 151, 91)) qp.drawText(GRID_ORIGINX+col*CELL_SIZE+(CELL_SIZE/2.2), GRID_ORIGINY+row*CELL_SIZE+(CELL_SIZE/1.8), \ str(self.__board[row][col])) else: qp.setFont(QFont("Arial", 20)) qp.setPen(QColor(185, 151, 91)) qp.drawText(GRID_ORIGINX+col*CELL_SIZE+(CELL_SIZE/2.4), GRID_ORIGINY+row*CELL_SIZE+(CELL_SIZE/1.8), \ str(self.__board[row][col])) else: qp.setBrush(QColor(185, 151, 91)) qp.setPen(QPen(Qt.black, 2)) qp.drawRect(GRID_ORIGINX+col*CELL_SIZE, GRID_ORIGINY+row*CELL_SIZE, CELL_SIZE, CELL_SIZE) # Winner Mode if self.is_winner() == True: qp.setPen(QPen(Qt.red)) qp.setFont(QFont("Arial", 20)) qp.drawText(GRID_ORIGINX*2.4, GRID_ORIGINY-20, "Game Over! You Win!") # Recording Moves qp.setPen(QPen(Qt.blue)) qp.setFont(QFont("Arial", 14)) qp.drawText(75, 550, ("Moves: " + str(self.__moves))) # Mii Music Button qp.setPen(QPen(Qt.black, 1)) qp.setBrush(QColor(17, 87, 64)) # Green qp.drawRect(185, 535, 75, 20) qp.setPen(QColor(185, 151, 91)) # Gold qp.setFont(QFont("Arial", 14)) qp.drawText(198, 550, "Play Mii") # BTS Music Button qp.setPen(QPen(Qt.black, 1)) qp.drawRect(295, 535, 75, 20) qp.setPen(QColor(185, 151, 91)) # Gold qp.setFont(QFont("Arial", 14)) qp.drawText(305, 550, "Play BTS") # No Music qp.setPen(QPen(Qt.black, 1)) qp.drawRect(405, 535, 72, 20) qp.setPen(QColor(185, 151, 91)) # Gold qp.setFont(QFont("Arial", 14)) qp.drawText(412, 550, "No Music") qp.end()
def draw_flag(self, qp): # Задаем кисть qp.setBrush(QColor(255, 255, 0)) R = random.randint(1, 500) qp.drawEllipse(20, 20, R, R)
def UpdatePacketTable(self,packet): '''Called each time sniffer captures a packet Thus glitches do appear when too many packets captured in a short time The function collects necessary info about packets and display in the table ''' row_number=self.packet_table.rowCount() if row_number: time=packet.time-self.sniffer.initial_time else: self.sniffer.initial_time=packet.time self.sniffer.sniffed_time=0 time=0 layer_number=2 layer=packet.getlayer(layer_number) while layer and layer.name not in ('Raw','Padding'): layer_number+=1 layer=packet.getlayer(layer_number) protocol=packet.getlayer(layer_number-1).name if protocol=='ARP': source=packet.getlayer(1).hwsrc destination=packet.getlayer(1).hwdst else: source=packet.getlayer(1).src destination=packet.getlayer(1).dst '''Further analyse protocol through ports''' if packet.haslayer(TCP) or packet.haslayer(UDP): sport,dport=packet.sport,packet.dport if protocol=='TCP': sport_string=packet[TCP].fields_desc[0].i2repr(packet,sport) dport_string=packet[TCP].fields_desc[1].i2repr(packet,dport) if sport_string!=str(sport): protocol=sport_string.upper() if dport_string!=str(dport): protocol=dport_string.upper() elif protocol=='UDP': sport_string=packet[UDP].fields_desc[0].i2repr(packet,sport) dport_string=packet[UDP].fields_desc[1].i2repr(packet,dport) if sport_string!=str(sport): protocol=sport_string.upper() if dport_string!=str(dport): protocol=dport_string.upper() else: sport,dport=None,None info_list=packet.summary().split(' / ')[1:] info_list.sort(key=lambda x:len(x)) '''The coloring rules are the default ones in Wireshark''' if protocol=='ARP': background,foreground=QColor(250,240,215),QColor(18,39,46) #ARP elif 'ICMP' in protocol: if protocol=='ICMP' and packet[ICMP].type in (3,4,5,11): background,foreground=QColor(18,39,46),QColor(183,247,116) #ICMP errors else: background,foreground=QColor(252,224,255),QColor(18,39,46) #ICMP or ICMPv6 elif packet.haslayer(TCP): flag=int(packet[TCP].flags) if flag>>2&1: background,foreground=QColor(164,0,0),QColor(255,252,156) #TCP reset elif sport==80 or dport==80: background,foreground=QColor(228,255,199),QColor(18,39,46) #HTTP elif flag&3: background,foreground=QColor(160,160,160),QColor(18,39,46) #TCP SYN/FIN else: background,foreground=QColor(231,230,255),QColor(18,39,46) #TCP elif packet.haslayer(UDP): background,foreground=QColor(218,238,255),QColor(18,39,46) #UDP else: background,foreground=QColor(255,255,255),QColor(18,39,46) '''('No.','Time','Source','Destination','Protocol','Length','Info',background,foreground,sport,dport,packet)''' packet_tuple=(str(row_number),'{:.6f}'.format(time),source,destination,\ protocol,str(len(packet)),info_list[-1],background,foreground,\ sport,dport,packet) self.sniffer.packet_filter.packet_list.append(packet_tuple) self.packet_table.insertRow(row_number) for column in range(7): self.packet_table.setItem(row_number,column,QTableWidgetItem(packet_tuple[column])) self.packet_table.item(row_number,column).setBackground(background) self.packet_table.item(row_number,column).setForeground(foreground) '''Avoid scrolling too fast''' if time>0.05+self.sniffer.sniffed_time: self.packet_table.scrollToBottom() self.sniffer.sniffed_time=time
def drawText(self, event, qp): qp.setPen(QColor(0, 0, 0)) qp.setFont(QFont('SansSerif', 12)) qp.drawText(event.rect(), Qt.AlignCenter, self.text)
def readSubstyles(self, editor): """ Public method to load the sub-styles and configure the editor. @param editor reference to the editor object @type QsciScintilla """ subStyleBasesLength = editor.SendScintilla( editor.SCI_GETSUBSTYLEBASES, 0, None) if not subStyleBasesLength: # lexer does not support sub-styling return self.loadSubstyles() # free existing sub-styles first editor.SendScintilla(editor.SCI_FREESUBSTYLES) subStyleBases = b"\00" * (subStyleBasesLength + 1) editor.SendScintilla(editor.SCI_GETSUBSTYLEBASES, 0, subStyleBases) distanceToSecondary = editor.SendScintilla( editor.SCI_DISTANCETOSECONDARYSTYLES) subStyleBases = [b for b in bytearray(subStyleBases[:-1])] if distanceToSecondary: subStyleBases.extend(b + distanceToSecondary for b in subStyleBases[:]) for baseStyleNo in subStyleBases: if baseStyleNo in self.__subStyles: subStylesData = self.__subStyles[baseStyleNo] subStyleLength = len(subStylesData) subStyleStart = editor.SendScintilla( editor.SCI_ALLOCATESUBSTYLES, baseStyleNo, subStyleLength) if subStyleStart < 0: continue subStyleIndex = -1 for subStyleKey in sorted(subStylesData.keys()): subStyleIndex += 1 styleNo = subStyleStart + subStyleIndex subStyle = subStylesData[subStyleKey] # set the words editor.SendScintilla( editor.SCI_SETIDENTIFIERS, styleNo, subStyle["Words"].encode()) # set the style style = subStyle["Style"] if "fore" in style: color = QColor( style["fore"] >> 16 & 0xff, style["fore"] >> 8 & 0xff, style["fore"] & 0xff, ) else: color = self.color(baseStyleNo) self.setColor(color, styleNo) if "paper" in style: color = QColor( style["paper"] >> 16 & 0xff, style["paper"] >> 8 & 0xff, style["paper"] & 0xff, ) else: color = self.paper(baseStyleNo) self.setPaper(color, styleNo) if "eolfill" in style: eolFill = style["eolfill"] else: eolFill = self.eolFill(baseStyleNo) self.setEolFill(eolFill, styleNo) font = self.font(baseStyleNo) if "font_family" in style: font.setFamily(style["font_family"]) if "font_size" in style: font.setPointSize(style["font_size"]) if "font_bold" in style: font.setBold(style["font_bold"]) if "font_italic" in style: font.setItalic(style["font_italic"]) if "font_underline" in style: font.setUnderline(style["font_underline"]) self.setFont(font, styleNo)
def color_row(self, row): for i in range(self.table_widget.columnCount()): self.table_widget.item(row, i).setBackground(QColor(0, 150, 100))
def __init__(self, parent=None): super(Main, self).__init__(parent) # VENTANA self.setWindowTitle("EXADATA") self.setFixedSize(800, 600) self.setWindowIcon(QIcon("icono.jpg")) # FRAME paleta = QPalette() paleta.setColor(QPalette.Background, QColor(51, 0, 102)) frame = QFrame(self) frame.setFrameShape(QFrame.NoFrame) frame.setFrameShadow(QFrame.Sunken) frame.setAutoFillBackground(True) frame.setPalette(paleta) frame.setFixedWidth(900) frame.setFixedHeight(100) frame.move(0, 0) labelIcono = QLabel(frame) labelIcono.setFixedWidth(65) labelIcono.setFixedHeight(65) labelIcono.setPixmap( QPixmap("icono.jpg").scaled(65, 65, Qt.KeepAspectRatio, Qt.SmoothTransformation)) labelIcono.move(10, 28) fuenteTitulo = QFont() fuenteTitulo.setPointSize(25) fuenteTitulo.setBold(True) labelTitulo = QLabel("<font color='white'>EXADATA</font>", frame) labelTitulo.setFont(fuenteTitulo) labelTitulo.move(85, 30) fuenteSubtitulo = QFont() fuenteSubtitulo.setPointSize(13) labelSubtitulo = QLabel("<font color='white'>Análisis de Tweets ", frame) labelSubtitulo.setFont(fuenteSubtitulo) labelSubtitulo.move(85, 68) labelVersion = QLabel(frame) labelVersion.setText(" EXADATA VERSIÓN BETA: 1.0 ") self.statusBar = self.statusBar() self.statusBar.addPermanentWidget(labelVersion, 0) oImage = QImage("back.jpg") sImage = oImage.scaled(QSize(800, 600)) palette = QPalette() palette.setBrush(10, QBrush(sImage)) # 10 = Windowrole self.setPalette(palette) #LOGO # BARRA MENU self.menubar = QtWidgets.QMenuBar(self) self.menubar.setGeometry(QtCore.QRect(0, 0, 900, 21)) self.menubar.setObjectName("menubar") # BOTON PROGRAMAS self.Programas = QtWidgets.QMenu(self.menubar) self.Apariencia = QtWidgets.QMenu(self.Programas) self.BaseDeDatos = QtWidgets.QAction(self) self.Muestra_Programa = QtWidgets.QAction(self) self.Cortar_Fecha = QtWidgets.QAction(self) self.Popularidad = QtWidgets.QAction(self) self.Nube_Palabras = QtWidgets.QAction(self) self.Bigramma = QtWidgets.QAction(self) self.Oscuro = QtWidgets.QAction(self) self.Claro = QtWidgets.QAction(self) # BOTON CONFIGURACIONES self.Configuracion = QtWidgets.QMenu(self.menubar) self.Programas.addAction(self.BaseDeDatos) self.Programas.addAction(self.Muestra_Programa) self.Programas.addAction(self.Cortar_Fecha) self.Programas.addAction(self.Popularidad) self.Programas.addAction(self.Nube_Palabras) self.Programas.addAction(self.Bigramma) self.Apariencia.addAction(self.Oscuro) self.Apariencia.addAction(self.Claro) self.Configuracion.addAction(self.Apariencia.menuAction()) self.menubar.addAction(self.Configuracion.menuAction()) # BOTON AYUDA self.Ayuda = QtWidgets.QMenu(self.menubar) self.Sobre_que = QtWidgets.QAction(self) self.Ayuda.addAction(self.Sobre_que) self.menubar.addAction(self.Programas.menuAction()) self.menubar.addAction(self.Ayuda.menuAction()) self.menubar.addAction(self.Configuracion.menuAction()) # FUNCIONES self.BARRAMENU(self)
def setStyle(app): from PyQt5.QtCore import Qt app.setStyle("Fusion") darkPalette = QPalette() darkPalette.setColor(QPalette.Window, QColor(53, 53, 53)) darkPalette.setColor(QPalette.WindowText, Qt.white) darkPalette.setColor(QPalette.Disabled, QPalette.WindowText, QColor(127, 127, 127)) darkPalette.setColor(QPalette.Base, QColor(42, 42, 42)) darkPalette.setColor(QPalette.AlternateBase, QColor(66, 66, 66)) darkPalette.setColor(QPalette.ToolTipBase, Qt.white) darkPalette.setColor(QPalette.ToolTipText, Qt.white) darkPalette.setColor(QPalette.Text, Qt.white) darkPalette.setColor(QPalette.Disabled, QPalette.Text, QColor(127, 127, 127)) darkPalette.setColor(QPalette.Dark, QColor(35, 35, 35)) darkPalette.setColor(QPalette.Shadow, QColor(20, 20, 20)) darkPalette.setColor(QPalette.Button, QColor(53, 53, 53)) darkPalette.setColor(QPalette.ButtonText, Qt.white) darkPalette.setColor(QPalette.Disabled, QPalette.ButtonText, QColor(127, 127, 127)) darkPalette.setColor(QPalette.BrightText, Qt.red) darkPalette.setColor(QPalette.Link, QColor(42, 130, 218)) darkPalette.setColor(QPalette.Highlight, QColor(42, 130, 218)) darkPalette.setColor(QPalette.Disabled, QPalette.Highlight, QColor(80, 80, 80)) darkPalette.setColor(QPalette.HighlightedText, Qt.white) darkPalette.setColor(QPalette.Disabled, QPalette.HighlightedText, QColor(127, 127, 127)) app.setPalette(darkPalette)
def resetOverlayColor(self): self._overlayColor = QColor(0, 0, .75, 150)
class HealthStatusDisplay(QObject): indicator_side = 10 indicator_border = 6 health_colors = { HEALTH_GOOD: QColor(Qt.green), HEALTH_DEAD: QColor(Qt.red), HEALTH_MOOT: QColor(Qt.yellow), HEALTH_UNCHECKED: QColor("#B5B5B5"), HEALTH_CHECKING: QColor(Qt.yellow), HEALTH_ERROR: QColor(Qt.red) } def draw_text(self, painter, rect, text, color=QColor("#B5B5B5"), font=None, alignment=Qt.AlignVCenter): painter.save() text_flags = Qt.AlignLeft | alignment | Qt.TextSingleLine text_box = painter.boundingRect(rect, text_flags, text) painter.setPen(QPen(color, 1, Qt.SolidLine, Qt.RoundCap)) if font: painter.setFont(font) painter.drawText(text_box, text_flags, text) painter.restore() def paint(self, painter, rect, index): data_item = index.model().data_items[index.row()] if u'health' not in data_item or data_item[u'health'] == "updated": data_item[u'health'] = get_health(data_item['num_seeders'], data_item['num_leechers'], data_item['last_tracker_check']) health = data_item[u'health'] # ---------------- # |b---b| | # |b|i|b| 0S 0L | # |b---b| | # ---------------- r = rect # Indicator ellipse rectangle y = r.top() + (r.height() - self.indicator_side) / 2 x = r.left() + self.indicator_border w = self.indicator_side h = self.indicator_side indicator_rect = QRect(x, y, w, h) # Paint indicator painter.save() painter.setBrush(QBrush(self.health_colors[health])) painter.setPen(QPen(self.health_colors[health], 0, Qt.SolidLine, Qt.RoundCap)) painter.drawEllipse(indicator_rect) painter.restore() x = indicator_rect.left() + indicator_rect.width() + 2 * self.indicator_border y = r.top() w = r.width() - indicator_rect.width() - 2 * self.indicator_border h = r.height() text_box = QRect(x, y, w, h) # Paint status text, if necessary if health in [HEALTH_CHECKING, HEALTH_UNCHECKED, HEALTH_ERROR]: self.draw_text(painter, text_box, health) else: seeders = int(data_item[u'num_seeders']) leechers = int(data_item[u'num_leechers']) txt = u'S' + str(seeders) + u' L' + str(leechers) self.draw_text(painter, text_box, txt)
def tab_indicator_color(self, idx): """Get the tab indicator color for the given index.""" try: return self.tab_data(idx, 'indicator-color') except KeyError: return QColor()
def paint(self, image): qp = QPainter(image) qp.setPen(QPen(QColor('blue'), 1)) qp.drawRect(QPolygon(self.selected.getPoints()).boundingRect())
def paintEvent(self, event): painter = QPainter(self) painter.setPen(self.pen) painter.setBrush(self.brush) if self.antialiased: painter.setRenderHint(QPainter.Antialiasing) angle_step = 360 / self.n_states painter.save() #Save_1. Save the state of the system (push matrix) painter.translate( self.dist_center.x(), self.dist_center.y()) # go to the center of the render area painter.rotate( -180 ) #to start painting from the left side of the circle (clockwise) #center of the circumference where through we are going to paint our states x = self.dist_radius * math.cos(0) y = self.dist_radius * math.sin(0) for h in range(self.n_states): rot = angle_step * h # each state is equidistant from the others. We paint them in circles painter.save() #Save_2 painter.rotate( rot) #now our system is pointing to the next state to be drawn painter.translate( x, y ) #now our origin is in the center of the next state to be drawn #if the state is active, fill it green if self.machine.getState(h).isActive(): painter.setBrush(self.greenGradientBrush) painter.drawEllipse(QPoint(0, 0), self.state_radius, self.state_radius) #draw the new state #global position of transformed coordinates (before any transformation, origin at top-left corner) gx = painter.worldTransform().map(QPoint(0, 0)).x() gy = painter.worldTransform().map(QPoint(0, 0)).y() self.machine.getState(h).setPos( gx, gy ) #store the center of the state without any transformation applied # text transformation. Our origin is still in the center of the current state painter.save() #Save_3 painter.rotate(180) #making the text go vertical painter.rotate( -rot ) #undoing the rotation made for painting the state. No the text is horizontal font = painter.font() font.setPixelSize(self.state_radius * .4) painter.setFont(font) rect = QRect(-self.state_radius, -self.state_radius, self.state_radius * 2, self.state_radius * 2) painter.drawText(rect, Qt.AlignCenter, self.machine.getState(h).getName()) painter.restore() #Restore_3 #end text transformation painter.restore() #Restore_2 painter.restore( ) #Restore_1. Restore the state of the system (pop matrix) #drawing transitions. Line between states painter.save() # Save_4 pptv = QTransform( ) #Define a new transformation. Needed to rotate the system along other axis than Z pptv.translate( 0, self.height()) #We are now at the bottom-left corner of the screen pptv.rotate( -180, Qt.XAxis ) #Rotate along the X-axis so now we are in a typical cartesian system. painter.setTransform(pptv) #Apply the transformation states = self.machine.getStates() for state in states: transitions = state.getTransitions() for transition in transitions: #get the center of the origin and destination states in our current system state orig = QPoint(state.getPos()[0], state.getPos()[1]) end = QPoint( self.machine.getState( transition.getStateEnd()).getPos()[0], self.machine.getState( transition.getStateEnd()).getPos()[1]) # get those coordinates without transformation orig2 = QPoint(painter.worldTransform().map(orig)) end2 = QPoint(painter.worldTransform().map(end)) #get the angle between states centers and the horizon angle = math.atan2(end2.y() - orig2.y(), end2.x() - orig2.x()) #get the coordinates of the starting point of the transition (it starts in the bound of the state, not in the center) newX = self.state_radius * math.cos(angle) + orig2.x() newY = self.state_radius * math.sin(angle) + orig2.y() #now the transition starts at the border, not in the center orig2.setX(newX) orig2.setY(newY) #same for the destination state angle2 = math.atan2(orig2.y() - end2.y(), orig2.x() - end2.x()) newX2 = self.state_radius * math.cos(angle2) + end2.x() newY2 = self.state_radius * math.sin(angle2) + end2.y() end2.setX(newX2) end2.setY(newY2) #draw the line between the origin and destination states painter.drawLine(orig2, end2) #get the start and the end of the transition untransformed init = QPoint(painter.worldTransform().map(orig2)) end = QPoint(painter.worldTransform().map(end2)) #store that info transition.setOrig(init.x(), init.y()) transition.setDest(end.x(), end.y()) transition.setAngle(angle) painter.restore() #Restore_4 #Appliying style to the transitions painter.setPen(QPen(QColor(Qt.gray), 3)) for state in self.machine.getStates(): for transition in state.getTransitions(): #get the start and end coordinates of the transition i = QPoint(transition.getOrig()[0], transition.getOrig()[1]) o = QPoint(transition.getDest()[0], transition.getDest()[1]) painter.drawPolyline(i, o) #Drawing the arrow at the end of the transition painter.save() #Save_5 painter.setPen(QPen(QColor(Qt.gray), 2)) painter.translate( transition.getDest()[0], transition.getDest()[1]) #Go to the end of the transition painter.rotate( 90 - transition.getAngle() * 180 / math.pi ) #Rotate to point in the direction of the transition #coordinates of the arrow (triangle) a = QPoint(0, 0) b = QPoint(-5, 10) c = QPoint(5, 10) #coordinates of the arrow untransformed a1 = painter.worldTransform().map(a) b1 = painter.worldTransform().map(b) c1 = painter.worldTransform().map(c) #Drawin the actual arrow pointer = QPolygon([a, b, c]) painter.drawPolygon(pointer) painter.restore() #Restore_5 #For the animation of the transition painter.save() #Save_6 if transition.isActive( ): #if the current transition is the active one the wave function will be running, so it's updating the canvas painter.setPen(QPen(QColor(Qt.green), 3)) painter.drawPolyline(i, o) painter.setPen(QPen(QColor(Qt.gray), 3)) painter.drawPolyline(self.poly(self.pts)) #Draw the arrow in the active state (red arrow) painter.setBrush(QBrush(QColor(255, 0, 0))) painter.setPen(QPen(QColor(Qt.red), 2)) pointer = QPolygon([a1, b1, c1]) painter.drawPolygon(pointer) #Ball that follows the line animation for x, y in self.pts: painter.drawEllipse( QRectF(self.pts[0][0] - 4, self.pts[0][1] - 4, 8, 8)) painter.restore() #Restore_6 #Painting the text of the transition painter.save() #Save_7 pptv = QTransform() painter.setPen(QPen(QColor(Qt.black), 3)) #get the middle point of the transition middleX = (transition.getOrig()[0] + transition.getDest()[0]) / 2 middleY = (transition.getOrig()[1] + transition.getDest()[1]) / 2 pptv.translate(middleX, middleY) #translate to that point painter.setTransform(pptv) #apply the transformation font = painter.font() font.setPixelSize(self.state_radius * .2) painter.setFont(font) rect = QRect(-self.state_radius, -self.state_radius, self.state_radius * 2, self.state_radius * 2) name = str(transition.getId()) + '. ' + transition.getName() painter.drawText(rect, Qt.AlignCenter, name) painter.restore() #Restore_7 #paint the actual canvas painter.setPen(self.palette().dark().color()) painter.setBrush(Qt.NoBrush) painter.drawRect(QRect(0, 0, self.width() - 1, self.height() - 1))
def updateMask(control_image_path, rendered_image_path, mask_image_path): control_image = imageFromPath(control_image_path) if not control_image: error('Could not read control image {}'.format(control_image_path)) rendered_image = imageFromPath(rendered_image_path) if not rendered_image: error('Could not read rendered image {}'.format(rendered_image_path)) if not rendered_image.width() == control_image.width( ) or not rendered_image.height() == control_image.height(): print( ('Size mismatch - control image is {}x{}, rendered image is {}x{}'. format(control_image.width(), control_image.height(), rendered_image.width(), rendered_image.height()))) max_width = min(rendered_image.width(), control_image.width()) max_height = min(rendered_image.height(), control_image.height()) # read current mask, if it exist mask_image = imageFromPath(mask_image_path) if mask_image.isNull(): print('Mask image does not exist, creating {}'.format(mask_image_path)) mask_image = QImage(control_image.width(), control_image.height(), QImage.Format_ARGB32) mask_image.fill(QColor(0, 0, 0)) # loop through pixels in rendered image and compare mismatch_count = 0 linebytes = max_width * 4 for y in range(max_height): control_scanline = control_image.constScanLine(y).asstring(linebytes) rendered_scanline = rendered_image.constScanLine(y).asstring(linebytes) mask_scanline = mask_image.scanLine(y).asstring(linebytes) for x in range(max_width): currentTolerance = qRed( struct.unpack('I', mask_scanline[x * 4:x * 4 + 4])[0]) if currentTolerance == 255: # ignore pixel continue expected_rgb = struct.unpack('I', control_scanline[x * 4:x * 4 + 4])[0] rendered_rgb = struct.unpack('I', rendered_scanline[x * 4:x * 4 + 4])[0] difference = colorDiff(expected_rgb, rendered_rgb) if difference > currentTolerance: # update mask image mask_image.setPixel(x, y, qRgb(difference, difference, difference)) mismatch_count += 1 if mismatch_count: # update mask mask_image.save(mask_image_path, "png") print('Updated {} pixels in {}'.format(mismatch_count, mask_image_path)) else: print('No mismatches in {}'.format(mask_image_path))
class InsertSinePlugin(SignalEditorPlugin): insert_sine_wave_clicked = pyqtSignal() INSERT_INDICATOR_COLOR = QColor(0, 255, 0, 80) def __init__(self): self.__dialog_ui = None # type: QDialog self.complex_wave = None self.__amplitude = 0.5 self.__frequency = 10 self.__phase = 0 self.__sample_rate = 1e6 self.__num_samples = int(1e6) self.original_data = None self.draw_data = None self.position = 0 super().__init__(name="InsertSine") @property def dialog_ui(self) -> QDialog: if self.__dialog_ui is None: dir_name = os.path.dirname( os.readlink(__file__)) if os.path.islink( __file__) else os.path.dirname(__file__) logging.getLogger().setLevel(logging.WARNING) self.__dialog_ui = uic.loadUi( os.path.realpath( os.path.join(dir_name, "insert_sine_dialog.ui"))) logging.getLogger().setLevel(logger.level) self.__dialog_ui.setAttribute(Qt.WA_DeleteOnClose) self.__dialog_ui.setModal(True) self.__dialog_ui.doubleSpinBoxAmplitude.setValue(self.__amplitude) self.__dialog_ui.doubleSpinBoxFrequency.setValue(self.__frequency) self.__dialog_ui.doubleSpinBoxPhase.setValue(self.__phase) self.__dialog_ui.doubleSpinBoxSampleRate.setValue( self.__sample_rate) self.__dialog_ui.doubleSpinBoxNSamples.setValue(self.__num_samples) self.__dialog_ui.lineEditTime.setValidator( QRegExpValidator( QRegExp("[0-9]+([nmµ]*|([\.,][0-9]{1,3}[nmµ]*))?$"))) scene_manager = SceneManager(self.dialog_ui.graphicsViewSineWave) self.__dialog_ui.graphicsViewSineWave.scene_manager = scene_manager self.insert_indicator = scene_manager.scene.addRect( 0, -2, 0, 4, QPen(QColor(Qt.transparent), 0), QBrush(self.INSERT_INDICATOR_COLOR)) self.insert_indicator.stackBefore( scene_manager.scene.selection_area) self.set_time() return self.__dialog_ui @property def amplitude(self) -> float: return self.__amplitude @amplitude.setter def amplitude(self, value: float): if value != self.amplitude: self.__amplitude = value self.draw_sine_wave() @property def frequency(self) -> float: return self.__frequency @frequency.setter def frequency(self, value: float): if value != self.frequency: self.__frequency = value self.draw_sine_wave() @property def phase(self) -> float: return self.__phase @phase.setter def phase(self, value: float): if value != self.phase: self.__phase = value self.draw_sine_wave() @property def sample_rate(self) -> float: return self.__sample_rate @sample_rate.setter def sample_rate(self, value: float): if value != self.sample_rate: self.__sample_rate = value self.set_time() self.draw_sine_wave() @property def num_samples(self) -> int: return self.__num_samples @num_samples.setter def num_samples(self, value: int): value = int(value) if value != self.num_samples: self.__num_samples = value self.set_time() self.draw_sine_wave() def create_connects(self): pass def create_dialog_connects(self): self.dialog_ui.doubleSpinBoxAmplitude.editingFinished.connect( self.on_double_spin_box_amplitude_editing_finished) self.dialog_ui.doubleSpinBoxFrequency.editingFinished.connect( self.on_double_spin_box_frequency_editing_finished) self.dialog_ui.doubleSpinBoxPhase.editingFinished.connect( self.on_double_spin_box_phase_editing_finished) self.dialog_ui.doubleSpinBoxSampleRate.editingFinished.connect( self.on_double_spin_box_sample_rate_editing_finished) self.dialog_ui.doubleSpinBoxNSamples.editingFinished.connect( self.on_spin_box_n_samples_editing_finished) self.dialog_ui.lineEditTime.editingFinished.connect( self.on_line_edit_time_editing_finished) self.dialog_ui.buttonBox.accepted.connect(self.on_button_box_accept) self.dialog_ui.buttonBox.rejected.connect(self.on_button_box_reject) self.__dialog_ui.finished.connect(self.on_dialog_finished) def get_insert_sine_dialog(self, original_data, position, sample_rate=None, num_samples=None) -> QDialog: if sample_rate is not None: self.sample_rate = sample_rate self.dialog_ui.doubleSpinBoxSampleRate.setValue(sample_rate) if num_samples is not None: self.__num_samples = int(num_samples) self.dialog_ui.doubleSpinBoxNSamples.setValue(num_samples) self.original_data = original_data self.position = position self.set_time() self.draw_sine_wave() self.create_dialog_connects() return self.dialog_ui def draw_sine_wave(self): if self.dialog_ui.graphicsViewSineWave.scene_manager: self.dialog_ui.graphicsViewSineWave.scene_manager.clear_path() QApplication.instance().setOverrideCursor(Qt.WaitCursor) self.__set_status_of_editable_elements(enabled=False) t = np.arange(0, self.num_samples) / self.sample_rate arg = 2 * np.pi * self.frequency * t + self.phase self.complex_wave = np.empty(len(arg), dtype=np.complex64) self.complex_wave.real = np.cos(arg) self.complex_wave.imag = np.sin(arg) self.complex_wave = IQArray(self.amplitude * self.complex_wave).convert_to( self.original_data.dtype) self.draw_data = np.insert(self.original_data[:, 0], self.position, self.complex_wave[:, 0]) y, h = self.dialog_ui.graphicsViewSineWave.view_rect().y( ), self.dialog_ui.graphicsViewSineWave.view_rect().height() self.insert_indicator.setRect(self.position, y - h, self.num_samples, 2 * h + abs(y)) self.__set_status_of_editable_elements(enabled=True) QApplication.instance().restoreOverrideCursor() self.dialog_ui.graphicsViewSineWave.plot_data(self.draw_data) self.dialog_ui.graphicsViewSineWave.show_full_scene() def __set_status_of_editable_elements(self, enabled: bool): for obj in ("doubleSpinBoxAmplitude", "doubleSpinBoxFrequency", "doubleSpinBoxPhase", "doubleSpinBoxSampleRate", "doubleSpinBoxNSamples", "lineEditTime", "buttonBox"): getattr(self.dialog_ui, obj).setEnabled(enabled) def set_time(self): self.dialog_ui.lineEditTime.setText( Formatter.science_time(self.num_samples / self.sample_rate, decimals=3, append_seconds=False, remove_spaces=True)) @pyqtSlot() def on_double_spin_box_amplitude_editing_finished(self): self.amplitude = self.dialog_ui.doubleSpinBoxAmplitude.value() @pyqtSlot() def on_double_spin_box_frequency_editing_finished(self): self.frequency = self.dialog_ui.doubleSpinBoxFrequency.value() @pyqtSlot() def on_double_spin_box_phase_editing_finished(self): self.phase = self.dialog_ui.doubleSpinBoxPhase.value() @pyqtSlot() def on_double_spin_box_sample_rate_editing_finished(self): self.sample_rate = self.dialog_ui.doubleSpinBoxSampleRate.value() @pyqtSlot() def on_spin_box_n_samples_editing_finished(self): self.num_samples = self.dialog_ui.doubleSpinBoxNSamples.value() @pyqtSlot() def on_line_edit_time_editing_finished(self): time_str = self.dialog_ui.lineEditTime.text().replace(",", ".") suffix = "" try: t = float(time_str) except ValueError: suffix = time_str[-1] try: t = float(time_str[:-1]) except ValueError: return factor = 10**-9 if suffix == "n" else 10**-6 if suffix == "µ" else 10**-3 if suffix == "m" else 1 time_val = t * factor if self.sample_rate * time_val >= 1: self.dialog_ui.doubleSpinBoxNSamples.setValue(self.sample_rate * time_val) self.dialog_ui.doubleSpinBoxNSamples.editingFinished.emit() else: self.set_time() @pyqtSlot() def on_button_box_reject(self): self.dialog_ui.reject() @pyqtSlot() def on_button_box_accept(self): self.insert_sine_wave_clicked.emit() self.dialog_ui.accept() @pyqtSlot() def on_dialog_finished(self): self.sender().graphicsViewSineWave.eliminate() self.__dialog_ui = None
def __init__(self, render_info): super().__init__() self.render_info = render_info self.color1 = QColor(0, 0, 0) self.color2 = QColor(0, 0, 0) self.wall_color = QColor(120, 120, 120)
def __init__(self, parent=None): super(AmzHistoryChart, self).__init__(parent=parent) self.dbsession = Session() self.context_menu_actions = [] self._avg_pointspan = 0 self._max_points = 100 self.source = None self.history = None layout = QVBoxLayout() layout.setContentsMargins(0, 0, 0, 0) self.setLayout(layout) # Set up the chart self.chart_view = QChartView(self) self.chart_view.setRenderHint(QPainter.Antialiasing) self.chart_view.setContextMenuPolicy(Qt.CustomContextMenu) self.chart_view.customContextMenuRequested.connect(self.context_menu) self.chart = QChart() self.chart.legend().hide() self.chart.setFlags(QGraphicsItem.ItemIsFocusable | QGraphicsItem.ItemIsSelectable) self.chart.installEventFilter(self) self.chart_view.setChart(self.chart) self.layout().addWidget(self.chart_view) # Create the axes rcolor = QColor(50, 130, 220) pcolor = QColor(0, 200, 0) ocolor = QColor(255, 175, 0) self.timeAxis = QDateTimeAxis() self.timeAxis.setFormat('M/dd hh:mm') self.timeAxis.setTitleText('Date/Time') self.chart.addAxis(self.timeAxis, Qt.AlignBottom) self.timeAxis.minChanged.connect(self.on_timeaxis_min_changed) self.rankAxis = QValueAxis() self.rankAxis.setLabelFormat('%\'i') self.rankAxis.setTitleText('Sales Rank') self.rankAxis.setLinePenColor(rcolor) self.rankAxis.setLabelsColor(rcolor) self.chart.addAxis(self.rankAxis, Qt.AlignLeft) self.priceAxis = QValueAxis() self.priceAxis.setLabelFormat('$%.2f') self.priceAxis.setTitleText('Price') self.priceAxis.setLinePenColor(pcolor) self.priceAxis.setLabelsColor(pcolor) self.chart.addAxis(self.priceAxis, Qt.AlignRight) # Create the series self.rankLine = QLineSeries() self.chart.addSeries(self.rankLine) self.rankLine.attachAxis(self.timeAxis) self.rankLine.attachAxis(self.rankAxis) self.rankLine.setColor(rcolor) self.priceLine = QLineSeries() self.chart.addSeries(self.priceLine) self.priceLine.attachAxis(self.timeAxis) self.priceLine.attachAxis(self.priceAxis) self.priceLine.setColor(pcolor) self.salesPoints = QScatterSeries() self.chart.addSeries(self.salesPoints) self.salesPoints.attachAxis(self.timeAxis) self.salesPoints.attachAxis(self.rankAxis) self.salesPoints.setColor(ocolor)
from PyQt5.QtGui import QPalette, QColor from PyQt5.QtWidgets import QApplication, QWidget, QPushButton, QGridLayout app = QApplication([]) window = QWidget() grid = QGridLayout() window.setLayout(grid) palette = QPalette() palette.setColor(QPalette.Window, QColor(43,49,55)) palette.setColor(QPalette.ButtonText, QColor(97, 175, 239)) app.setPalette(palette) grid.addWidget(QPushButton('1'), 1, 1) grid.addWidget(QPushButton('2'), 1, 2) grid.addWidget(QPushButton('3'), 2, 1) grid.addWidget(QPushButton('4'), 2, 2) window.show() app.exec_()
def data(self, index, role=Qt.DisplayRole): data = None if not index.isValid(): return QVariant(data) if role not in [ Qt.DisplayRole, Qt.EditRole, Qt.ToolTipRole, Qt.FontRole, Qt.BackgroundRole ]: return None mn = self.masternodes[index.row()] i = index.column() if i == self.ALIAS: data = mn.alias elif i == self.STATUS: status = self.manager.masternode_statuses.get( mn.get_collateral_str()) data = masternode_status(status) if role == Qt.BackgroundRole: data = QBrush( QColor(ENABLED_MASTERNODE_BG)) if data[0] else None # Return the long description for data widget mappers. elif role == Qt.EditRole: data = data[2] else: data = data[1] elif i == self.VIN: txid = mn.vin.get('prevout_hash', '') out_n = str(mn.vin.get('prevout_n', '')) addr = mn.vin.get('address', '') value = str(mn.vin.get('value', '')) scriptsig = mn.vin.get('scriptSig', '') if role == Qt.EditRole: data = ':'.join([txid, out_n, addr, value, scriptsig]) elif role == Qt.FontRole: data = util.MONOSPACE_FONT else: if all(attr for attr in [txid, out_n, addr]): data = '%s:%s' % (txid, out_n) else: data = '' elif i == self.COLLATERAL: data = mn.collateral_key if role in [Qt.EditRole, Qt.DisplayRole, Qt.ToolTipRole] and data: data = bitcoin.public_key_to_p2pkh(bfh(data)) elif role == Qt.FontRole: data = util.MONOSPACE_FONT elif i == self.DELEGATE: data = mn.delegate_key if role in [Qt.EditRole, Qt.DisplayRole, Qt.ToolTipRole] and data: data = self.manager.get_delegate_privkey(data) elif role == Qt.FontRole: data = util.MONOSPACE_FONT elif i == self.ADDR: data = '' if mn.addr.ip: data = str(mn.addr) elif i == self.PROTOCOL_VERSION: data = mn.protocol_version return QVariant(data)
def as_color(self, background=False): color = self._get_color(background) return QColor(color)
def resetState(self): self._color = QColor(0, 0, 0, 150)
def on_update(self): def item_path( item ): # Recursively builds the path for an item eg 'parent_name/item_name' return item.text(0) if not item.parent() else item_path( item.parent()) + "/" + item.text(0) def remember_expanded_items(root): # Save the set of expanded items... so that address list updates don't annoyingly collapse # our tree list widget due to the update. This function recurses. Pass self.invisibleRootItem(). expanded_item_names = set() for i in range(0, root.childCount()): it = root.child(i) if it and it.childCount(): if it.isExpanded(): expanded_item_names.add(item_path(it)) expanded_item_names |= remember_expanded_items( it) # recurse return expanded_item_names def restore_expanded_items(root, expanded_item_names): # Recursively restore the expanded state saved previously. Pass self.invisibleRootItem(). for i in range(0, root.childCount()): it = root.child(i) if it and it.childCount(): restore_expanded_items( it, expanded_item_names) # recurse, do leaves first old = bool(it.isExpanded()) new = bool(item_path(it) in expanded_item_names) if old != new: it.setExpanded(new) self.wallet = self.parent.wallet had_item_count = self.topLevelItemCount() sels = self.selectedItems() addresses_to_re_select = {item.data(0, Qt.UserRole) for item in sels} expanded_item_names = remember_expanded_items(self.invisibleRootItem()) del sels # avoid keeping reference to about-to-be delete C++ objects self.clear() receiving_addresses = self.wallet.get_receiving_addresses() change_addresses = self.wallet.get_change_addresses() if self.parent.fx and self.parent.fx.get_fiat_address_config(): fx = self.parent.fx else: fx = None account_item = self sequences = [0, 1] if change_addresses else [0] items_to_re_select = [] for is_change in sequences: if len(sequences) > 1: name = _("Receiving") if not is_change else _("Change") seq_item = QTreeWidgetItem([name, '', '', '', '', '']) account_item.addChild(seq_item) if not is_change and not had_item_count: # first time we create this widget, auto-expand the default address list seq_item.setExpanded(True) expanded_item_names.add(item_path(seq_item)) else: seq_item = account_item used_item = QTreeWidgetItem([_("Used"), '', '', '', '', '']) used_flag = False addr_list = change_addresses if is_change else receiving_addresses for n, address in enumerate(addr_list): num = len(self.wallet.get_address_history(address)) is_used = self.wallet.is_used(address) balance = sum(self.wallet.get_addr_balance(address)) address_text = address.to_ui_string() label = self.wallet.labels.get(address.to_storage_string(), '') balance_text = self.parent.format_amount(balance, whitespaces=True) columns = [address_text, str(n), label, balance_text, str(num)] if fx: rate = fx.exchange_rate() fiat_balance = fx.value_str(balance, rate) columns.insert(4, fiat_balance) address_item = SortableTreeWidgetItem(columns) address_item.setTextAlignment(3, Qt.AlignRight) address_item.setFont(3, QFont(MONOSPACE_FONT)) if fx: address_item.setTextAlignment(4, Qt.AlignRight) address_item.setFont(4, QFont(MONOSPACE_FONT)) address_item.setFont(0, QFont(MONOSPACE_FONT)) address_item.setData(0, Qt.UserRole, address) address_item.setData(0, Qt.UserRole + 1, True) # label can be edited if self.wallet.is_frozen(address): address_item.setBackground(0, QColor('lightblue')) if self.wallet.is_beyond_limit(address, is_change): address_item.setBackground(0, QColor('red')) if is_used: if not used_flag: seq_item.insertChild(0, used_item) used_flag = True used_item.addChild(address_item) else: seq_item.addChild(address_item) if address in addresses_to_re_select: items_to_re_select.append(address_item) for item in items_to_re_select: # NB: Need to select the item at the end becasue internally Qt does some index magic # to pick out the selected item and the above code mutates the TreeList, invalidating indices # and other craziness, which might produce UI glitches. See #1042 item.setSelected(True) # Now, at the very end, enforce previous UI state with respect to what was expanded or not. See #1042 restore_expanded_items(self.invisibleRootItem(), expanded_item_names)
def __init__(self): QMainWindow.__init__(self) #self.setWindowFlags(Qt.CustomizeWindowHint) #self.setWindowFlags(Qt.WindowMinMaxButtonsHint) # creating map canvas, which draws the maplayers # setting up features like canvas color self.canvas = QgsMapCanvas() self.canvas.setMinimumSize(550, 700) self.canvas.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Preferred) self.canvas.setCanvasColor(Qt.white) self.canvas.setSelectionColor(QColor(255, 255, 26, 200)) self.canvas.enableAntiAliasing(True) self.canvas.setParallelRenderingEnabled(True) # empty list for selected polygons self.selected_features = [] # setting up label settings: object below houses all of them self.label_settings = QgsPalLayerSettings() # object for text settings text_format = QgsTextFormat() text_format.setFont(QFont("Helvetica", 12)) text_format.setSize(7) # setting up a white buffer around the labels buffer_settings = QgsTextBufferSettings() buffer_settings.setEnabled(True) buffer_settings.setSize(0.65) buffer_settings.setColor(Qt.white) text_format.setBuffer(buffer_settings) # label settings: # fieldName = which field is shown as the label (currently Finnish name) # placement = labels can be placed differently in relation to one another # - see documentation for details self.label_settings.setFormat(text_format) self.label_settings.fieldName = "namefin" self.label_settings.placement = 0 self.label_settings.enabled = True # Qmainwindow requires a central widget. Canvas is placed self.setCentralWidget(self.canvas) # creating each desired action self.actionGet = QAction("Return selected and close", self) self.actionPan = QAction("Pan tool", self) self.actionSelect = QAction("Select tool", self) self.actionClear = QAction("Clear selection", self) self.actionCancel = QAction("Cancel and close", self) # these two function as on/off. the rest are clickable self.actionPan.setCheckable(True) self.actionSelect.setCheckable(True) # when actions are clicked, do corresponding function self.actionPan.triggered.connect(self.pan) self.actionSelect.triggered.connect(self.select) self.actionClear.triggered.connect(self.clearSelection) self.actionGet.triggered.connect(self.finishedSelection) self.actionCancel.triggered.connect(self.cancel) # toolbar at the top of the screen: houses actions as buttons # change order here to change their placement on window self.toolbar = self.addToolBar("Canvas actions") self.toolbar.setContextMenuPolicy(Qt.PreventContextMenu) self.toolbar.setMovable(False) self.toolbar.addAction(self.actionGet) self.toolbar.addAction(self.actionPan) self.toolbar.addAction(self.actionSelect) self.toolbar.addAction(self.actionClear) self.toolbar.addAction(self.actionCancel) # link actions to premade map tools self.toolPan = QgsMapToolPan(self.canvas) self.toolPan.setAction(self.actionPan) self.toolSelect = QgsMapToolIdentifyFeature(self.canvas) self.toolSelect.setAction(self.actionSelect) self.toolSelect.featureIdentified.connect(self.selectFeature) self.blocks_flag = False self.selection_rectangle = False # set select tool as default self.select()
self.notify_label.setText("Scan above QR to copy information") self.notify_label.setFont(self.notify_font) self.notify_label.setAlignment(Qt.AlignCenter) self.notify_label.setStyleSheet("color: #eee") layout = QVBoxLayout(self) layout.setContentsMargins(0, 0, 0, 0) layout.addStretch() layout.addWidget(self.qrcode_label, 0, Qt.AlignCenter) layout.addSpacing(20) layout.addWidget(self.file_name_label, 0, Qt.AlignCenter) layout.addSpacing(40) layout.addWidget(self.notify_label, 0, Qt.AlignCenter) layout.addStretch() self.qrcode_label.setPixmap( qrcode.make(url, image_factory=Image).pixmap()) if __name__ == "__main__": from PyQt5.QtWidgets import QApplication import sys import signal app = QApplication(sys.argv) test = AirShareWidget("/home/andy/rms/1.jpg", QColor(0, 0, 0, 255)) test.show() signal.signal(signal.SIGINT, signal.SIG_DFL) sys.exit(app.exec_())
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 txpos = tx_item['txpos'] if timestamp is None: status_str = 'unconfirmed' else: status_str = format_time(int(timestamp)) else: tx_hash = tx_item['txid'] conf = tx_item['confirmations'] txpos = tx_item['txpos_in_block'] or 0 height = tx_item['height'] 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) # we sort by timestamp if timestamp is None: timestamp = float("inf") if role == Qt.UserRole: # for sorting d = { HistoryColumns.STATUS: # height breaks ties for unverified txns # txpos breaks ties for verified same block txns (-timestamp, conf, -status, -height, -txpos) if not is_lightning else (-timestamp, 0,0,0,-txpos), 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)\ + (tx_item['balance_msat']//1000 if 'balance_msat'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: msg = 'lightning transaction' if is_lightning else 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.STATUS 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 __init__(self, buffer_id, url): Buffer.__init__(self, buffer_id, url, False, QColor(0, 0, 0, 255)) self.add_widget(AirShareWidget(url, QColor(0, 0, 0, 255)))
def __init__(self, parent=None): ''' Initialize the flowsheet display ''' super(fsScene, self).__init__(parent) # Location of mouse events and whether the mouse button is down self.mouseDown = False self.pressX = 0.0 self.pressY = 0.0 self.releaseX = 0.0 self.releaseY = 0.0 # self.minorGrid = 20 # Minor grid spacing self.majorGrid = 100 # Major grid spacing self.xMaxGrid = 800 # Extent of grid area up x self.xMinGrid = -800 # Extent of grid area lo x self.yMaxGrid = 600 # Extent of grid area up y self.yMinGrid = -600 # Extent of grid area lo y self.nodeSize = 20 # size of node self.edgeArrowSize = 16 # size of the edge arrows self.actNodeSize = 25 # size of an active node self.mode = self.MODE_SELECT # Mouse mode self.p = parent # Parent class self.node1 = None # Node 1 for drawing edges self.node2 = None # Node 2 for drawing edges self.selectedNodes = [] # Set of selected nodes self.selectedEdges = [] # Set of selected edges self.majorGridPen = None # Pen for major grids self.minorGridPen = None # Pen for minor grids self.edgePen = None # Pen for edges self.tearEdgePen = None # Pen for tear edges self.nodePen = None # Pen for nodes self.activeNodePen = None # Pen for active node self.selectionPen = None # Pen for node selection markers self.eSelectionPen = None # Pen for edge selection markers # # Line styles self.lcMajorGrid = QColor(255, 190, 240) # minor grid color self.lcMinorGrid = QColor(190, 240, 255) # major grid color self.ltGrid = QtCore.Qt.DashLine # grid line type self.lwMinorGrid = 1 # grid line width self.lwMajorGrid = 1 # # self.lcEdge = QColor(0, 50, 200) self.ltEdge = QtCore.Qt.SolidLine self.lwEdge = 2 self.lcTear = QColor(100, 200, 255) self.ltTear = QtCore.Qt.SolidLine # self.lcNode = QColor(0, 0, 0) self.ltNode = QtCore.Qt.SolidLine self.lwNode = 2 self.lcActNode = QColor(0, 0, 0) # self.lcSelect = QColor(0, 255, 0) self.ltSelect = QtCore.Qt.SolidLine self.lwSelect = 4 self.lwEdgeSelect = 10 # # Set font self.font = None self.fontSize = 12 # # Set Brushes self.nodeBrush = None self.actNodeBrush = None # self.fcNode = QColor(128, 128, 128) self.fcActNode = QColor(128, 250, 128) self.fpNode = QtCore.Qt.SolidPattern self.fpActNode = QtCore.Qt.SolidPattern # self.edgeArrowBrush = None self.fcEdgeArrow = QColor(0, 50, 200) self.fpEdgeArrow = QtCore.Qt.SolidPattern # self.whiteBrush = None self.fcWB = QColor(240, 240, 240) self.fpWB = QtCore.Qt.SolidPattern # self.loadPens() #setup pens, brushes, and font
def color(self, color): pal = self.palette() pal.setColor(QPalette.Background, QColor(color)) self.setPalette(pal)