def open_file(self):
path, _ = QFileDialog.getOpenFileName(
self, "Open file", "",
"PNG image files (*.png); JPEG image files (*jpg); All files (*.*)"
)
if path:
pixmap = QPixmap()
pixmap.load(path)
iw = pixmap.width()
ih = pixmap.height()
cw, ch = CANVAS_DIMENSIONS
if iw / cw < ih / ch:
pixmap = pixmap.scaledToWidth(cw)
hoff = (pixmap.height() - ch) // 2
pixmap = pixmap.copy(
QRect(QPoint(0, hoff), QPoint(cw,
pixmap.height() - hoff)))
elif iw / cw > ih / ch:
pixmap = pixmap.scaledToHeight(ch)
woff = (pixmap.width() - cw) // 2
pixmap = pixmap.copy(
QRect(QPoint(woff, 0), QPoint(pixmap.width() - woff, ch)))
self.canvas.setPixmap(pixmap)
def ret():
files = os.listdir("./Images/roi")
start = time.time()
if type == "orb":
f = self.orb
elif type == "sift":
f = self.sift
elif type == "surf":
f = self.surf
res = 99999999
name = None
for i in files:
img = cv2.imread("./Images/roi/" + i)
#img = utils.hand2(img)
# cv2.imwrite("pipei.jpg", img)
# img = cv2.imread("pipei.jpg")
res_ = f(img)
res_ = res_ if res_ is not None else 9999999
name = name if res_ > res else i
res = res if res_ > res else res_
if name is not None:
stop = time.time()
runtime = stop - start
ret = QPixmap()
ret.load('./Images/' + name)
self.ui.label_2.setPixmap(ret)
self.ui.label_2.setScaledContents(True)
rname = re.sub(r'[0-9].*$', "", name)
if rname in self.kv.keys():
rname = self.kv[rname]
# QMessageBox.about(self, "掌纹主人的名字为:", rname)
QMessageBox.about(
self, "输出", "掌纹主人的名字为: " + rname + '\n耗时：' +
'{0:.2f}'.format(runtime) + '秒')
class QToolWindowDropTarget(QWidget):
def __init__(self, imagePath, areaReference):
super().__init__(None)
self.pixmap = QPixmap()
self.areaReference = areaReference
self.setWindowFlags(QtCore.Qt.Tool | QtCore.Qt.FramelessWindowHint
| QtCore.Qt.WindowStaysOnTopHint)
self.setAttribute(QtCore.Qt.WA_TranslucentBackground)
self.setAttribute(QtCore.Qt.WA_ShowWithoutActivating)
if QtCore.QFile.exists(imagePath):
self.pixmap.load(imagePath)
else:
qWarning(imagePath + " not found.")
self.setFixedSize(self.pixmap.size())
def __del__(self):
if self.pixmap:
del self.pixmap
def target(self):
return self.areaReference
def paintEvent(self, paintEvent):
painter = QPainter(self)
painter.drawPixmap(0, 0, self.pixmap)
def initializeWithRowID(self, rowid, deckname):
self.current_rowid = rowid
self.deckname = deckname
self.clearDrawView()
pixmap = QPixmap()
self.imageView.setPixmap(pixmap)
result = self.dbAdapter.selectDeckItem(rowid)
self.dataset = result
svgsavepath = path.join(self.deckpath, result["svg_filename"])
self.svg_filename = result["svg_filename"]
self.freehandDrawWidget.loadView(svgsavepath)
self.nameLine.setText(result["name"])
self.wordLine.setText(result["word"])
self.phoneticalLine.setText(result["phonetical"])
self.translationLine.setText(result["translation"])
if 'image' in result and result['image']:
pixmap = QPixmap()
pixmap.load(path.join(self.deckpath, result['image']))
pixmap = pixmap.scaled(QSize(600, 300), Qt.KeepAspectRatio)
self.imageView.setPixmap(pixmap)
self.imageView.show()
self.audioListWidget.initAudioListWidget(self.dbAdapter, self.deckpath, self.current_rowid)
self.audioListWidget.getAudioFromDB(self.current_rowid)
class Example(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.setGeometry(300, 300, 600, 400)
self.setWindowTitle('Вторая программа')
self.btn = QPushButton('111', self)
self.btn.move(120, 340)
self.btn.clicked.connect(self.run)
self.file_name = QLineEdit(self)
self.file_name.move(140, 20)
print("test")
print("test2")
self.pixmap = QPixmap()
self.image = QLabel(self)
self.image.move(1280, 260)
self.image.resize(250, 250)
self.image.setPixmap(self.pixmap)
def run(self):
self.pixmap.load(self.file_name.text())
self.image.setPixmap(self.pixmap)
def open_file(self):
"""
Open image file for editing, scaling the smaller dimension and cropping the remainder.
:return:
"""
path, _ = QFileDialog.getOpenFileName(
self, "Open file", "",
"PNG image files (*.png); JPEG image files (*jpg); All files (*.*)"
)
if path:
pixmap = QPixmap()
pixmap.load(path)
# We need to crop down to the size of our canvas. Get the size of the loaded image.
iw = pixmap.width()
ih = pixmap.height()
# Get the size of the space we're filling.
cw, ch = CANVAS_DIMENSIONS
if iw / cw < ih / ch: # The height is relatively bigger than the width.
pixmap = pixmap.scaledToWidth(cw)
hoff = (pixmap.height() - ch) // 2
pixmap = pixmap.copy(
QRect(QPoint(0, hoff), QPoint(cw,
pixmap.height() - hoff)))
elif iw / cw > ih / ch: # The height is relatively bigger than the width.
pixmap = pixmap.scaledToHeight(ch)
woff = (pixmap.width() - cw) // 2
pixmap = pixmap.copy(
QRect(QPoint(woff, 0), QPoint(pixmap.width() - woff, ch)))
self.imagefilePath = path # for the opened sketch files
self.ui.Canvas.setPixmap(pixmap)
def clearance(self, fn, args):
if fn == 'select':
self.selectImg(args[0], args[1], args[2], args[3], args[4],
args[5], args[6], args[7])
self.alphaChanger(args[8], args[9], args[10])
elif fn == 'add':
self.addImg(args[0], args[1], args[2], args[3], args[4], args[5],
args[6])
elif fn == 'delete':
self.deleteImg(args[0])
elif fn == 'search':
file_path = self.findImg()[0]
if len(file_path) > 0:
args[0].setText(file_path)
pixmap = QPixmap()
pixmap.load(file_path)
fit_pixmap = pixmap.scaled(args[1].size(), Qt.KeepAspectRatio,
Qt.FastTransformation)
args[1].setPixmap(fit_pixmap)
rvfile_path = file_path[::-1]
file = rvfile_path.split('.')[1]
file = file.split('/')[0]
args[2].setText(file[::-1])
elif fn == 'paint':
self.myPalette(args[0])
elif fn == 'slider':
self.alphaChanger(args[0], args[1], args[2])
def generate_preview(self):
if self.doc:
try:
self.preview.clear()
page = self.ui.spinPreview.value()
doc_hash = hashlib.md5(self.doc.path).hexdigest()
tmp_pdf_file = os.path.abspath(
os.path.join('./tmp',
doc_hash + '-{}'.format(page) + '.pdf'))
tmp_img_file = os.path.abspath(
os.path.join('./tmp',
doc_hash + '-{}'.format(page) + '.png'))
if not os.path.exists(tmp_pdf_file):
shutil.copy(self.doc.path, tmp_pdf_file)
if not os.path.exists(tmp_img_file):
img = Image(filename=tmp_pdf_file + '[{}]'.format(page))
img.save(filename=tmp_img_file)
pixmap = QPixmap()
pixmap.load(tmp_img_file)
self.preview.addPixmap(pixmap)
self.generated_preview_files.add(tmp_pdf_file)
self.generated_preview_files.add(tmp_img_file)
except Exception as ex:
QMessageBox.warning(
self, 'Error!',
'Could not generate preview: {}'.format(ex.message))
def initPeople():
self.peopleList = []
image = QPixmap()
image.load("1.png")
image2 = QPixmap()
image2.load("2.png")
r = self.peopleRadius * self.sizePerPoint
for i in range(len(people_list)):
p = people_list[i]
label = QLabel(self)
px = (p[1] - self.peopleRadius) * self.sizePerPoint + self.paintX0
py = (p[0] - self.peopleRadius) * self.sizePerPoint + self.paintY0
label.setGeometry(px, py, self.sizePerPoint * self.peopleRadius * 2,
self.sizePerPoint * self.peopleRadius * 2)
if i < bound:
label.setPixmap(image2)
pType = 0
else:
label.setPixmap(image)
pType = 1
label.setScaledContents(True)
path = QPolygonF()
path << QPointF(px + r, py + r)
self.peopleList.append([label, path, pType])
self.arriveList = []
class Hand:
def __init__(self):
self.userHands = {
'rock': 'image/rock.png',
'paper': 'image/paper.png',
'scissors': 'image/scissors.png'
}
self.pcHands = {
'rock': 'image/reversedRock.png',
'paper': 'image/reversedPaper.png',
'scissors': 'image/reversedScissors.png'
}
self.userHand = QPixmap()
self.pcHand = QPixmap()
def randomPcHand(self):
return random.choice(list(self.pcHands.keys()))
def getPcHand(self, currentPcHand):
self.pcHand.load(self.pcHands[currentPcHand])
self.pcHand = self.pcHand.scaled(250, 250)
return self.pcHand
def getUserHand(self, hand):
self.userHand.load(self.userHands[hand])
self.userHand = self.userHand.scaled(250, 250)
return self.userHand
class Photo(QWidget):
def __init__(self, parent=None, photo=None, acc=None):
QWidget.__init__(self, parent)
self.acc = acc
if photo == None:
self.pixmap = QPixmap()
self.pixmap.load('./src/sheep_icon.png')
labelImg = QLabel()
myPixmap = self.pixmap.scaled(150, 150, Qt.KeepAspectRatio,
Qt.FastTransformation)
labelImg.setPixmap(myPixmap)
else:
self.pixmap = QPixmap()
self.pixmap.loadFromData(photo.content)
labelImg = QLabel()
myPixmap = self.pixmap.scaled(150, 150, Qt.KeepAspectRatio,
Qt.FastTransformation)
labelImg.setPixmap(myPixmap)
layout = QHBoxLayout()
layout.addWidget(labelImg)
layout.addWidget(QLabel(acc.name))
layout.addWidget(QLabel(acc.last_name))
self.setLayout(layout)
def mouseDoubleClickEvent(self, QMouseEvent):
ChangeAvatar(self, self.acc.session, self.acc.token)
class Example(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.setGeometry(100, 100, 1000, 900)
self.setWindowTitle('15_2')
self.btn = QPushButton('Вывести картинку', self)
self.btn.move(20, 20)
self.btn.clicked.connect(self.run)
self.file_name = QLineEdit(self)
self.file_name.move(150, 20)
self.pixmap = QPixmap()
self.image = QLabel(self)
self.image.move(80, 60)
self.image.resize(950, 750)
self.image.setPixmap(self.pixmap)
def run(self):
self.pixmap.load(self.file_name.text())
self.image.setPixmap(self.pixmap)
self.image.resize(self.pixmap.width(), self.pixmap.height())
def updateDataLayout(self):
user_path = '../user_image/'
if self.login_start == True:
user_name = self.user_image_name + '.png'
else:
user_name = "Not_LOGIN" + '.png'
pixmap = QPixmap()
pixmap.load(user_path + user_name)
pixmap_resize = pixmap.scaled(self.size().width() / 16 * 9 / 3,
self.size().width() / 16 * 9 / 3,
Qt.KeepAspectRatio)
self.user_widget.setPixmap(pixmap_resize)
item_path = '../item_image/'
if self.cell_clicked == True:
item_name = self.item_image_name + '.jpg'
else:
item_name = "Not_LOGIN" + '.png'
pixmap = QPixmap()
pixmap.load(item_path + item_name)
pixmap_resize = pixmap.scaled(self.size().width() / 16 * 9 / 3,
self.size().width() / 16 * 9 / 3,
Qt.KeepAspectRatio)
self.item_widget.setPixmap(pixmap_resize)
def setSrc(self, src):
src = str(src)
if 'http' in src or 'https' in src:
cacheList = os.listdir(cacheFolder)
name = makeMd5(src)
localSrc = cacheFolder + '/' + name
if name in cacheList:
self.setSrc(localSrc)
self.src = localSrc
return
self.loadImg(src, name)
else:
self.src = src
pix = QPixmap(src)
pix.load(src)
pix = pix.scaled(self.width, self.height)
# mask需要与pix是相同大小。
if self.pixMask:
mask = QPixmap(self.pixMask)
mask = mask.scaled(self.width, self.height)
pix.setMask(mask.createHeuristicMask())
self.setPixmap(pix)
async def loadImg(self, src, name):
try:
async with aiohttp.ClientSession() as session:
async with session.get(src, headers=headers,
timeout=60) as response:
if response.status == 200:
image_content = await response.read()
else:
raise aiohttp.ClientError()
except Exception as e:
print(e)
return
width = self.width
height = self.height
pic = QPixmap()
pic.loadFromData(image_content)
localSrc = cacheFolder + '/' + name
pic.save(localSrc, 'jpg')
pic = pic.scaled(width, height)
self.src = localSrc
# 上遮罩。
if self.pixMask:
mask = QPixmap()
mask.load(self.pixMask)
mask = mask.scaled(width, height)
pic.setMask(mask.createHeuristicMask())
self.setPixmap(pic)
class LabelWithOkCancelIcon(QWidget):
"""
Displays small icon with ok/cancel icon and a text to the right.
"""
def __init__(self, parent: QWidget = None):
super(LabelWithOkCancelIcon, self).__init__(parent)
self.layout = QHBoxLayout()
self.layout.setSpacing(2)
self.layout.setContentsMargins(2, 2, 2, 2)
self.setLayout(self.layout)
self.icon_label = QLabel(self)
self.label = QLabel(self)
self.layout.addWidget(self.icon_label)
self.layout.addWidget(self.label)
self.layout.addStretch()
self.pixmap = QPixmap()
self._ok_status = False
def set_ok_status(self, ok_status: bool):
self._ok_status = ok_status
if ok_status:
self.pixmap.load('img/ok_icon.png')
else:
self.pixmap.load('img/cancel_icon.png')
self.icon_label.setPixmap(self.pixmap.scaled(32, 32))
def ok_status(self) -> bool:
return self._ok_status
def set_text(self, text: str):
self.label.setText(text)
def text(self) -> str:
return str(self.label.text())
class gameWidget(QWidget): #classe de l'aire d'affichage qp = None # Q painter brush = None # Q brush background_pm = None # pixmap pour le background game = None def __init__(self, parent, game): super().__init__(parent) self.qp = QPainter() self.game = game self.background_pm = QPixmap() self.background_pm.load(IMAGEPATH_BACKGROUND) #self.background_pm = QPixmap() #self.brush = QBrush(Qt.SolidPattern) self.setGeometry(0, 0, 100, 100) #self.resize(WINDOW_WIDTH, WINDOW_HEIGHT) self.resize(GAME_AREA_WIDTH, GAME_AREA_HEIGHT) self.move(300, 300) self.show() def paintEvent(self, event): self.qp.begin(self) #self.qp.setBrush(self.brush) #afficher le background #self.qp.drawRect(0, 0, 10000, 10000) self.qp.drawPixmap(0,0, GAME_AREA_WIDTH, GAME_AREA_HEIGHT,self.background_pm) #afficher les objets for objet in self.game.objectsList: objet.draw(self.qp) # ___ self.qp.end()
class Example(QWidget):
def __init__(self):
super().__init__()
self.cars = ['car2.png', 'car3.png', 'car4.png']
self.current = 'car2.png'
self.initUI()
def initUI(self):
self.setGeometry(300, 300, 300, 300)
self.setWindowTitle('Машинка')
self.pixmap = QPixmap(self.cars[0])
self.lbl = QLabel(self)
self.lbl.setPixmap(self.pixmap)
self.show()
def mouseMoveEvent(self, event):
if (event.x() in range(0, 250) and event.y() in range(0, 250)):
self.lbl.move(event.x(), event.y())
def keyPressEvent(self, event):
if event.key() == Qt.Key_Space:
tmp = copy.copy(self.cars)
tmp.remove(self.current)
self.current = random.choice(tmp)
self.pixmap.load(self.current)
self.lbl.setPixmap(self.pixmap)
class MainWindow(QMainWindow, Form):
def __init__(self):
super().__init__()
self.setupUi(self)
# 이미지 띄우기
# QPixmap 객체
self.pixmap = QPixmap()
self.pixmap.load('1.jpg')
# 이미지를 추가할 라벨
self.pixmap = self.pixmap.scaled(371, 371)
self.label_pic.setPixmap(self.pixmap) # 이미지 세팅
# QSliter 추가
self.dial_test.setNotchesVisible(True)
self.dial_test.valueChanged.connect(self.value_changed)
# QSlider 데이터를 표시할 라벨
self.textEdit_2.setStyleSheet("border-radius: 5px;"
"border: 1px solid gray;"
"background-color: #ffffff")
# 슬라이드 시그널 valueChanged 연결 함수
def value_changed(self, value):
self.textEdit_2.setText(str(value) + "시")
self.textEdit_2.setAlignment(Qt.AlignRight | Qt.AlignVCenter)
self.textEdit_2.setReadOnly(True)
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent) #inherit Ui_MainWindow
self.setupUi(self) #Build UI
#"self.pushButton" funciton is in the UI.Ui_MainWindow
#Cuz Ui_MainWindow is already inherited, implement self.pushButton
# You have to check your button objectname
self.pushButton.clicked.connect(self.clicked)
self.lineEdit.setText('Hi') #put text in lineEdit when start
self.pushButton_2.clicked.connect(
self.button2Clicked) # You have to check your button objectname
self.setWindowTitle('This is our test!!') # MainWindow Title
self.setWindowIcon(
QtGui.QIcon(
'C://Users//craig//PycharmProjects//Stock_Predict//venv//picture//icon.png'
)) # Set Window Icon
image = QPixmap() # Pixmap
image.load(
'C://Users//craig//PycharmProjects//Stock_Predict//venv//picture//superpan.png'
) #load image
image = image.scaled(self.width(), self.height()) #scale the image
palette = QPalette() # Palette
palette.setBrush(self.backgroundRole(),
QtGui.QColor(200, 200, 100)) #bg img setting
self.setPalette(palette) #Apply the setting
class WindowClass(QMainWindow, form_class):
def __init__(self):
super().__init__()
self.setupUi(self)
self.btn_loadFromFile.clicked.connect(self.loadFromFile)
self.btn_loadFromWeb.clicked.connect(self.loadFromWeb)
self.btn_save.clicked.connect(self.save)
def loadFromFile(self):
#QPixmap 객체 생성-> 이미지 파일을 객체에 load->label을 이용해 하면 표시
self.qpixmapvar = QPixmap()
self.qpixmapvar.load("check.jpg")
self.qpixmapvar = self.qpixmapvar.scaledToWidth(600)
self.label_pixmap.setPixmap(self.qpixmapvar)
def loadFromWeb(self):
urlString = "http://photo.hankooki.com/newsphoto/v001/2018/12/06/eyoree20181206143240_B_01_C_1.jpg"
imageFromWeb = urllib.request.urlopen(urlString).read()
self.qpixmapvar2 = QPixmap()
self.qpixmapvar2.loadFromData(imageFromWeb)
#self.qpixmapvar2 = self.qpixmapvar2.scaledToWidth(500)
self.label_pixmap.setPixmap(self.qpixmapvar2)
def save(self):
self.qpixmapSaveVar = self.label_pixmap.pixmap()
self.qpixmapSaveVar.save("Penguin.jpg")
def __init__(self, parent):
super().__init__(parent)
self.setWindowTitle("RHD2000 On-Chip Filters")
image = QPixmap()
image.load(":/images/help_diagram_chip_filters.png", "PNG")
imageLabel = QLabel()
imageLabel.setPixmap(image)
label1 = QLabel(
"Each amplifier on an RHD2000 chip has a pass band defined by analog circuitry "
"that includes a high-pass filter and a low-pass filter. The lower end of the pass "
"band has a first-order high-pass characteristic. The upper end of the pass "
"band is set by a third-order Butterworth low-pass filter.")
label1.setWordWrap(True)
label2 = QLabel(
"Each RHD2000 includes an on-chip module that performs digital signal processing "
"(DSP) to implement an additional first-order high-pass filter on each digitized amplifier "
"waveform. This feature is used to remove the residual DC offset voltages associated "
"with the analog amplifiers.")
label2.setWordWrap(True)
label3 = QLabel(
"The diagram below shows a simplified functional diagram of one channel in an "
"RHD2000 chip. For more information, consult the <b>RHD2000 series digital "
"physiology interface chip datasheet</b>, "
"which can be found on the Downloads page of the Intan Technologies website."
)
label3.setWordWrap(True)
label4 = QLabel(
"The general recommendation for best linearity is to set the DSP cutoff frequency to "
"the desired low-frequency cutoff and to set the amplifier lower bandwidth 2x to 10x "
"lower than this frequency. Note that the DSP cutoff frequency has a limited frequency "
"resolution (stepping in powers of two), so if a precise value of low-frequency cutoff "
"is required, the amplifier lower bandwidth could be used to define this and the DSP "
"cutoff frequency set 2x to 10x below this point. If both the DSP cutoff frequency and "
"the amplifier lower bandwidth are set to the same (or similar) frequencies, the actual "
"3-dB cutoff frequency will be higher than either frequency due to the combined effect of "
"the two filters.")
label4.setWordWrap(True)
label5 = QLabel(
"For a detailed mathematical description of all three on-chip filters, visit the "
"Downloads page on the Intan Technologies website and consult the document <b>FAQ: "
"RHD2000 amplifier filter characteristics</b>.")
label5.setWordWrap(True)
mainLayout = QVBoxLayout()
mainLayout.addWidget(label1)
mainLayout.addWidget(label2)
mainLayout.addWidget(label3)
mainLayout.addWidget(imageLabel)
mainLayout.addWidget(label4)
mainLayout.addWidget(label5)
self.setLayout(mainLayout)
def set_labels(self):
logger.debug("set_labels:begin")
titlePix = QPixmap()
titlePix.load('icons/titleIcon.png')
self.headIcon.setPixmap(titlePix.scaled(40, 40))
self.headTitle.setText("Wins百宝箱")
self.topSpace.setText("")
logger.debug("set_labels:end")
def return_img_path(self, path: str):
icon = QPixmap()
icon.load(path)
label = QLabel()
label.setAlignment(Qt.AlignCenter)
label.setPixmap(icon)
label.setStyleSheet("background-color: #CECECE;")
return label
def set_image_detail(self, face):
pixmap = QPixmap()
if face.thumbnail.width > 0:
pixmap.loadFromData(face.thumbnail.data)
else:
pixmap.load('avatar.png')
self.detail_face = face
self.image_detail.setPixmap(pixmap)
def set_qrcode(self, qrcode_path):
if os.path.exists(qrcode_path):
pix = QPixmap()
pix.load(qrcode_path)
item = QGraphicsPixmapItem(pix)
scene = QGraphicsScene()
scene.addItem(item)
self.qrcode_viewer.setScene(scene)
def load_current_image(self):
self.update_states()
file_name = self.get_current_image_file_name()
pixmap = QPixmap()
pixmap.load(file_name)
self.label_image.setPixmap(pixmap)
def getIcons(self):
arrowLeft = QPixmap()
arrowRight = QPixmap()
arrowLeft.load(self.imgPath + 'arrow_left.png')
arrowRight.load(self.imgPath + 'arrow_right.png')
self.iconArrLeft = QIcon(arrowLeft)
self.iconArrRight = QIcon(arrowRight)
class MyDialog(QDialog):
def __init__(self):
super().__init__()
self.ui = Ui_Dialog()
self.ui.setupUi(self)
self.pixmap = QPixmap()
self.pixmap.load('game_map.png')
self.item = QGraphicsPixmapItem(self.pixmap)
self.scene = QGraphicsScene()
self.scene.addItem(self.item)
self.ui.graphicsView.setScene(self.scene)
self.ui.pushButton.clicked.connect(self.startanimation)
self.path = QPainterPath()
self.path.moveTo(30,30)
self.path.cubicTo(30,30,80,180,180,170)
self.ui.label.pos = QPointF(20,20)
self.pos1 = [0,0]
self.pos2 = [0,0]
def mousePressEvent(self, event):
if event.buttons() & QtCore.Qt.LeftButton:
self.pos1[0] = event.x()
self.pos1[1] = event.y()
def mouseReleaseEvent(self, event):
self.pos2[0] = event.x()
self.pos2[1] = event.y()
self.update()
def paintEvent(self, event):
width = self.pos2[0] - self.pos1[0]
height = self.pos2[1] - self.pos1[1]
rect = QRect(self.pos1[0],self.pos1[1],width,height)
qp = QPainter()
qp.begin(self)
pen = QPen(Qt.red,3)
pen.setStyle(Qt.DotLine)
qp.setPen(pen)
qp.drawArc(rect,0,360*16)
qp.end()
# def paintEvent(self,e):
# qp = QPainter()
# qp.begin(self)
# qp.drawPath(self.path)
# qp.end()
def startanimation(self):
self.anim = QPropertyAnimation(self.ui.label, b'pos')
self.anim.setDuration(4000)
self.anim.setStartValue(QPointF(20,20))
pos = [n/80 for n in range(0,50)]
for i in pos:
self.anim.setKeyValueAt(i,self.path.pointAtPercent(i))
self.anim.setEndValue(QPointF(160,150))
self.anim.start()
def paintEvent(self, QPaintEvent):
super().paintEvent(QPaintEvent)
painter = QPainter(self)
pix = QPixmap()
pix.load(config.LEFT_ICON)
painter.translate(50, 50) # 让图片的中心作为旋转的中心
painter.rotate(90) # 顺时针旋转90度
painter.translate(-50, -50) # 使原点复原
painter.drawPixmap(0, 0, 100, 100, pix)
def add_image_to_gui(self, isgood, face):
pixmap = QPixmap()
if face.thumbnail.width > 0:
pixmap.loadFromData(face.thumbnail.data)
else:
pixmap.load('avatar.png')
image_item = QtWidgets.QListWidgetItem(QIcon(pixmap), face.name)
listwidget = self.good_images if isgood else self.bad_images
listwidget.addItem(image_item)
def paperCliked(self, event):
pixmap = QPixmap()
pixmap.load("res/checked.png")
self.ui.check_paper.setPixmap(pixmap)
pixmap.load("res/unchecked.png")
self.ui.check_maze.setPixmap(pixmap)
self.settings["game_type"] = 1
class MyWidget(QMainWindow):
def __init__(self):
super().__init__()
uic.loadUi('untitled.ui', self)
self.x0 = 0
self.y0 = 0
self.x = 0
self.y = 0
self.pixmap = QPixmap()
self.cutButton.clicked.connect(self.run)
self.imButton.clicked.connect(self.open_file)
def open_file(self):
try:
W = self.imageframe.width()
H = self.imageframe.height()
self.pixmap.load(self.lineEdit.text())
self.imageframe.setPixmap(
self.pixmap.scaled(W, H, Qt.KeepAspectRatio))
maxsize = (W, H)
image = self.lineEdit.text()
im = Image.open(image)
tn_image = im.thumbnail(maxsize, PIL.Image.ANTIALIAS)
im.save("temp.jpg")
except Exception:
pass
def run(self):
PhotoShop(self.x0, self.y0, self.x, self.y, "temp.jpg")
'''
W =self.imageframe.width()
H = self.imageframe.height()
self.pixmap.load(self.lineEdit.text())
self.imageframe.setPixmap(self.pixmap.scaled(W,H, Qt.KeepAspectRatio))
maxsize = (W, H)
image = self.lineEdit.text()
im = Image.open(image)
tn_image = im.thumbnail(maxsize, PIL.Image.ANTIALIAS)
im.save("temp.jpg")
bytes = QByteArray()
buffer = QBuffer()
buffer.open(QIODevice.WriteOnly)
self.pixmap.save(buffer, "PNG")'''
def mousePressEvent(self, event):
self.x0 = event.x()
self.y0 = event.y()
def mouseReleaseEvent(self, event):
self.x = event.x()
self.y = event.y()
self.coord.setText("Координаты:{}, {},{},{}".format(
self.x0, self.y0, self.x, self.y))
def textClicked(self, event):
pixmap = QPixmap()
pixmap.load("res/checked.png")
self.ui.check_text.setPixmap(pixmap)
pixmap.load("res/unchecked.png")
self.ui.check_pic.setPixmap(pixmap)
self.settings["pic_detect"] = 1
self.settings["text_detect"] = 1
def itemSelectionChanged(self):
if not self.pauseUpdate:
selected = self.fileTreeWidget.selectedItems()
if len(selected) < 1:
self.previewLabel.clear()
else:
image = QPixmap()
imagePath = selected[0].text(4) + "/" + selected[0].text(0)
image.load(imagePath)
widgetWidth = self.previewLabel.width()
self.previewLabel.setPixmap(image.scaledToWidth(widgetWidth))
def __setImagePixmapToIamgeLabel(self,img,bytesblag=True):
"""
设置预览图片,强行定义其大小为768,432
"""
pixmap = QPixmap()
if bytesblag == True:
pixmap.loadFromData(img)
else:
pixmap.load(img)
pixmap = pixmap.scaled(768,432)
self.image_label.setPixmap(pixmap)
self.image_label.setScaledContents(True)
def _load_icon(filename, backgroundColor, width, height):
foreground = QPixmap()
foreground.load(filename)
pixmap = QPixmap(foreground.size())
pixmap.fill(backgroundColor)
painter = QPainter()
painter.begin(pixmap)
painter.drawPixmap(QPointF(0, 0), foreground)
painter.end()
pixmap = pixmap.scaled(QSize(width, height), Qt.KeepAspectRatio, Qt.SmoothTransformation)
return pixmap
def data(self, index, role):
#
if role == Qt.BackgroundColorRole and (index.column() == self.ColumnID.Fix or index.column() == self.ColumnID.FixIcon):
row = index.row()
value = self._elements[row]
if value.isFixed:
color=QColor(Qt.red)
color.setAlphaF(0.5)
return color
if role == Qt.DisplayRole and index.column() == self.ColumnID.Text:
row = index.row()
value = self._elements[row]
return value.density
if role == Qt.DisplayRole and index.column() == self.ColumnID.Fix:
row = index.row()
value = self._elements[row]
return value.fixvalue
if role == Qt.DecorationRole and index.column() == self.ColumnID.Color:
row = index.row()
value = self._elements[row]
pixmap = QPixmap(_NPIXELS, _NPIXELS)
pixmap.fill(value.color)
icon = QIcon(pixmap)
return icon
if role == Qt.DecorationRole and index.column() == self.ColumnID.FixIcon:
row = index.row()
value = self._elements[row]
pixmap = QPixmap(_NPIXELS,_NPIXELS)
if value.isFixed:
iconpath=os.path.join(os.path.split(__file__)[0],
'icons/lock-edit-icon-32.png')
else:
iconpath=os.path.join(os.path.split(__file__)[0],
'icons/lock_open-32.png')
pixmap.load(iconpath)
icon = QIcon(pixmap)
return icon
return super(BoxListModel,self).data(index, role)
def store_file(self, id, file):
id = id.replace('/', '_')
directory = ApplicationData.get('images')
filename = os.path.join(directory, id + '.png')
if filename == os.path.normpath(file):
return self.iconmap.get(id, None)
makedirs(directory)
pixmap = QPixmap()
if file is not None and pixmap.load(file):
if pixmap.size().width() > self.max_size or pixmap.size().height() > self.max_size:
pixmap = pixmap.scaled(self.max_size, self.max_size, Qt.KeepAspectRatio, Qt.SmoothTransformation)
buffer = QBuffer()
pixmap.save(buffer, 'png')
data = str(buffer.data())
with open(filename, 'wb') as f:
f.write(data)
icon = QIcon(pixmap)
icon.filename = filename
icon.content = data
icon.content_type = 'image/png'
else:
unlink(filename)
icon = None
self.iconmap[id] = icon
return icon
def set_labels(self):
"""
全部的标签组件。
"""
p = QPixmap()
p.load('icons/unlogin.png')
p2 = QPixmap()
p2.load('icons/titleIcon.png')
# 头部装饰start。
self.lbe_pic.setObjectName("headpic")
self.lbe_pic.setPixmap(p.scaled(40, 40))
self.header_hr.setObjectName('Headerhr')
self.header_hr.setText("推荐")
self.header_icon.setObjectName('HIcon')
self.header_icon.setPixmap(p2.scaled(50, 50))
self.header_text.setObjectName('HText')
self.header_text.setText(" Music")
def refreshInfo(self):
#setup avata
pixmap = QPixmap()
pixmap.load("res/avata_mask")
pixmap.scaled(115, 115)
self.ui.lb_avata.setMask(pixmap.mask())
pixmap.load(self.settings["avata"])
self.ui.lb_avata.setPixmap(pixmap)
# self.ui.lb_avata2.setMask(pixmap.mask())
# pixmap.load(self.settings["avata"])
# self.ui.lb_avata2.setPixmap(pixmap)
#setup the name
self.ui.lb_welcomname.setText(self.settings["name"])
self.ui.lb_nick.setText(self.settings["name"])
def __init__(self, module):
QPushButton.__init__(self)
self.module = module
self.setParent(module)
eyeOn = QPixmap()
eyeOff = QPixmap()
eyeOn.load('%s/%s' % (module.mainWindow.imgPath, 'eye_on.png'))
eyeOff.load('%s/%s' % (module.mainWindow.imgPath, 'eye_off.png'))
self.iconEyeOn = QIcon(eyeOn)
self.iconEyeOff = QIcon(eyeOff)
self.mainWindow = module.mainWindow
self.setFixedSize(30, 20)
self.clicked.connect(self.showGB)
self.setCheckable(True)
self.showGB()
def getIcons(self):
arrow_left = QPixmap()
arrow_right = QPixmap()
arrow_left.load(self.path_img + 'arrow_left.png')
arrow_right.load(self.path_img + 'arrow_right.png')
self.icon_arrow_left = QIcon(arrow_left)
self.icon_arrow_right = QIcon(arrow_right)
icon_math = QPixmap()
icon_math.load(self.path_img + 'xy2.png')
icon_math_on = QPixmap()
icon_math_on.load(self.path_img + 'xy2_on.png')
self.icon_vcursor = QIcon(icon_math)
self.icon_vcursor_on = QIcon(icon_math_on)
icon_fit = QPixmap()
icon_fit.load(self.path_img + 'infini.png')
self.icon_fit = QIcon(icon_fit)
def __init__(self, parent=None, size=16):
super(SearchIcon, self).__init__(parent)
self.setFocusPolicy(Qt.NoFocus)
self.setVisible(True)
self.setMinimumSize(size+2, size+2)
pixmap = QPixmap()
if pixmap.load(Resources.get("icons/search.svg")):
self.icon = pixmap.scaled(size, size, Qt.KeepAspectRatio, Qt.SmoothTransformation)
else:
self.icon = None
def findIconHelper(self, size = int, themeName = str, iconName = str):
pixmap = QPixmap()
if iconName == '' or self.themeName == '':
return pixmap
if themeName == '':
themeName = self.themeName
if themeName == self.themeName:
index = self.themeIndex
else:
index = self.readThemeIndex(themeName)
subDirs = filter(lambda x:x[0] == str(size), index.dirList)
for iconDir in self.iconDirs:
if path.exists(path.join(iconDir, themeName)):
for theme in subDirs:
fileName = path.join(iconDir, themeName, theme[1],
'%s.png' % str(iconName))
logging.debug('Looking for : %s' % fileName)
if path.exists(fileName):
pixmap.load(fileName)
logging.debug('Icon: %s found in theme %s' % \
(iconName, themeName))
return pixmap
for iconDir in self.extraIcons:
fileName = path.join(iconDir, '%s.png' % str(iconName))
if path.exists(fileName):
pixmap.load(fileName)
logging.debug('Icon: %s found in %s' % (iconName, iconDir))
return pixmap
if len(self._themes) > 0:
self._themes.pop(0)
if not len(self._themes) == 0 and pixmap.isNull():
pixmap = self.findIconHelper(size, self._themes[0], iconName)
return pixmap
def __init__(self, data, **kwargs):
super(LinkWidget, self).__init__(**kwargs)
self.setupUi(self)
filename, links = data
self.groupBox.setTitle(path.split(filename)[1])
pixmap = QPixmap()
pixmap.load(filename)
self.pixmap = pixmap.scaled(120, 120, Qt.KeepAspectRatio)
self.label_picture.setPixmap(self.pixmap)
self.lineEdit_sharelink.setText(links['sharelink'])
self.lineEdit_hotlink.setText(links['hotlink'])
self.lineEdit_deletelink.setText(links['delete_url'])
self.lineEdit_preview.setText(links['thumbnail'])
self.lineEdit_sharelink.setCursorPosition(0)
self.lineEdit_hotlink.setCursorPosition(0)
self.lineEdit_deletelink.setCursorPosition(0)
self.lineEdit_preview.setCursorPosition(0)
def findIconHelper(self, size = int, themeName = str, iconName = str):
pixmap = QPixmap()
if iconName == '' or self.themeName == '':
return pixmap
if themeName == '':
themeName = self.themeName
if themeName == self.themeName:
index = self.themeIndex
else:
index = self.readThemeIndex(themeName)
subDirs = filter(lambda x:x[0] == str(size), index.dirList)
for iconDir in self.iconDirs:
if path.exists(path.join(iconDir, themeName)):
for theme in subDirs:
fileName = path.join(iconDir, themeName, theme[1],
'%s.png' % str(iconName))
fileName_svg = path.join(iconDir, themeName, theme[1],
'%s.svg' % str(iconName))
logging.debug('Looking for : %s' % fileName)
if path.exists(fileName):
pixmap.load(fileName)
logging.debug('Icon: %s found in theme %s' % \
(iconName, themeName))
return pixmap
elif path.exists(fileName_svg):
pixmap.load(fileName_svg)
logging.debug('Icon: %s found in %s' % (iconName, iconDir))
return pixmap
for iconDir in self.extraIcons:
fileName = path.join(iconDir, '%s.png' % str(iconName))
fileName_svg = path.join(iconDir, '{}.svg'.format(str(iconName)))
if path.exists(fileName):
pixmap.load(fileName)
#print "pixmap ->{}".format(fileName)
logging.debug('Icon: %s found in %s' % (iconName, iconDir))
return pixmap
elif path.exists(fileName_svg):
image=QImage(size, size, QImage.Format_RGB32)
reader=QImageReader(fileName)
reader.read(image)
pixmap.convertFromImage(image)
logging.debug('Icon: %s found in %s' % (iconName, iconDir))
#print "pixmap ->{}".format(fileName)
return pixmap
if len(self._themes) > 0:
self._themes.pop(0)
if not len(self._themes) == 0 and pixmap.isNull():
pixmap = self.findIconHelper(size, self._themes[0], iconName)
return pixmap
def openImage(self, path=None):
if not path:
path, _ = QFileDialog.getOpenFileName(self, "Open Image", '',
"Image Files (*.png *.jpg *.bmp)")
if path:
newImage = QPixmap()
if not newImage.load(path):
QMessageBox.warning(self, "Open Image",
"The image file could not be loaded.",
QMessageBox.Cancel)
return
self.puzzleImage = newImage
self.setupPuzzle()
def __init__(self, parent=None, size=16):
super(ClearButton, self).__init__(parent)
self.setCursor(Qt.ArrowCursor)
self.setFocusPolicy(Qt.NoFocus)
self.setToolTip(u"Clear")
self.setVisible(False)
self.setMinimumSize(size+2, size+2)
pixmap = QPixmap()
if pixmap.load(Resources.get("icons/delete.svg")):
self.icon = pixmap.scaled(size, size, Qt.KeepAspectRatio, Qt.SmoothTransformation)
# Use QImage because QPainter using a QPixmap does not support CompositionMode_Multiply -Dan
image = self.icon.toImage()
painter = QPainter(image)
painter.setRenderHint(QPainter.Antialiasing, True)
painter.setCompositionMode(QPainter.CompositionMode_Multiply)
painter.drawPixmap(0, 0, self.icon)
painter.end()
self.icon_pressed = QPixmap(image)
else:
self.icon = self.icon_pressed = None
def addBackgroundImage(self):
lastDirectory = self.mw.welcome.getLastAccessedDirectory()
"""File dialog that request an existing file. For opening an image."""
filename = QFileDialog.getOpenFileName(self,
self.tr("Open Image"),
lastDirectory,
self.tr("Image files (*.jpg; *.jpeg; *.png)"))[0]
if filename:
try:
px = QPixmap()
valid = px.load(filename)
del px
if valid:
shutil.copy(filename, writablePath("resources/backgrounds"))
return os.path.basename(filename)
else:
QMessageBox.warning(self, self.tr("Error"),
self.tr("Unable to load selected file"))
except Exception as e:
QMessageBox.warning(self, self.tr("Error"),
self.tr("Unable to add selected image:\n{}").format(str(e)))
return None
class RenderArea(QWidget):
points = QPolygon([
QPoint(10, 80),
QPoint(20, 10),
QPoint(80, 30),
QPoint(90, 70)
])
Line, Points, Polyline, Polygon, Rect, RoundedRect, Ellipse, Arc, Chord, \
Pie, Path, Text, Pixmap = range(13)
def __init__(self, parent=None):
super(RenderArea, self).__init__(parent)
self.pen = QPen()
self.brush = QBrush()
self.pixmap = QPixmap()
self.shape = RenderArea.Polygon
self.antialiased = False
self.transformed = False
self.pixmap.load(':/images/qt-logo.png')
self.setBackgroundRole(QPalette.Base)
self.setAutoFillBackground(True)
def minimumSizeHint(self):
return QSize(100, 100)
def sizeHint(self):
return QSize(400, 200)
def setShape(self, shape):
self.shape = shape
self.update()
def setPen(self, pen):
self.pen = pen
self.update()
def setBrush(self, brush):
self.brush = brush
self.update()
def setAntialiased(self, antialiased):
self.antialiased = antialiased
self.update()
def setTransformed(self, transformed):
self.transformed = transformed
self.update()
def paintEvent(self, event):
rect = QRect(10, 20, 80, 60)
path = QPainterPath()
path.moveTo(20, 80)
path.lineTo(20, 30)
path.cubicTo(80, 0, 50, 50, 80, 80)
startAngle = 30 * 16
arcLength = 120 * 16
painter = QPainter(self)
painter.setPen(self.pen)
painter.setBrush(self.brush)
if self.antialiased:
painter.setRenderHint(QPainter.Antialiasing)
for x in range(0, self.width(), 100):
for y in range(0, self.height(), 100):
painter.save()
painter.translate(x, y)
if self.transformed:
painter.translate(50, 50)
painter.rotate(60.0)
painter.scale(0.6, 0.9)
painter.translate(-50, -50)
if self.shape == RenderArea.Line:
painter.drawLine(rect.bottomLeft(), rect.topRight())
elif self.shape == RenderArea.Points:
painter.drawPoints(RenderArea.points)
elif self.shape == RenderArea.Polyline:
painter.drawPolyline(RenderArea.points)
elif self.shape == RenderArea.Polygon:
painter.drawPolygon(RenderArea.points)
elif self.shape == RenderArea.Rect:
painter.drawRect(rect)
elif self.shape == RenderArea.RoundedRect:
painter.drawRoundedRect(rect, 25, 25, Qt.RelativeSize)
elif self.shape == RenderArea.Ellipse:
painter.drawEllipse(rect)
elif self.shape == RenderArea.Arc:
painter.drawArc(rect, startAngle, arcLength)
elif self.shape == RenderArea.Chord:
painter.drawChord(rect, startAngle, arcLength)
elif self.shape == RenderArea.Pie:
painter.drawPie(rect, startAngle, arcLength)
elif self.shape == RenderArea.Path:
painter.drawPath(path)
elif self.shape == RenderArea.Text:
painter.drawText(rect, Qt.AlignCenter,
"PyQt by\nRiverbank Computing")
elif self.shape == RenderArea.Pixmap:
painter.drawPixmap(10, 10, self.pixmap)
painter.restore()
painter.setPen(self.palette().dark().color())
painter.setBrush(Qt.NoBrush)
painter.drawRect(QRect(0, 0, self.width() - 1, self.height() - 1))
class Planet_BuildItemWidget(QFrame):
# bitem, optional quantity for shipyard
requestBuildItem = pyqtSignal(XNPlanetBuildingItem, int)
# downgrade a building
requestDowngradeItem = pyqtSignal(XNPlanetBuildingItem)
def __init__(self, parent: QWidget):
super(Planet_BuildItemWidget, self).__init__(parent)
# data members
self._bitem = XNPlanetBuildingItem()
self._pix = QPixmap()
self._pix_met = QPixmap(':/i/s_metall.png')
self._pix_cry = QPixmap(':/i/s_kristall.png')
self._pix_deit = QPixmap(':/i/s_deuterium.png')
self._pix_energy = QPixmap(':/i/s_energy.png')
# setup frame
self.setFrameShape(QFrame.StyledPanel)
self.setFrameShadow(QFrame.Raised)
# font
font = self.font()
font.setWeight(QFont.Bold)
# layout
self._layout = QHBoxLayout()
self._layout_v = QVBoxLayout()
self.setLayout(self._layout)
# label with building image
self._lbl_pix = QLabel(self)
# labels for name and level
self._layout_nl = QHBoxLayout()
self._lbl_name = QLabel(self)
self._lbl_name.setFont(font)
self._lbl_lvl = QLabel(self)
# labels for time
self._layout_buildtime = QHBoxLayout()
self._lbl_time = QLabel(self.tr('Time:'), self)
self._lbl_timestr = QLabel(self)
# labels for price
self._layout_price1 = QHBoxLayout()
self._layout_price2 = QHBoxLayout()
self._layout_price3 = QHBoxLayout()
self._layout_price4 = QHBoxLayout()
self._lbl_price_met_ico = QLabel(self)
self._lbl_price_met_ico.setPixmap(self._pix_met)
self._lbl_price_met = QLabel()
self._lbl_price_cry_ico = QLabel()
self._lbl_price_cry_ico.setPixmap(self._pix_cry)
self._lbl_price_cry = QLabel()
self._lbl_price_deit_ico = QLabel()
self._lbl_price_deit_ico.setPixmap(self._pix_deit)
self._lbl_price_deit = QLabel()
self._lbl_price_energy_ico = QLabel()
self._lbl_price_energy_ico.setPixmap(self._pix_energy)
self._lbl_price_energy = QLabel()
# buttons
# upgrade
self._layout_buttons = QHBoxLayout()
self._btn_upgrade = QPushButton(self.tr('Upgrade'), self)
self._btn_upgrade.setIcon(QIcon(':/i/build.png'))
self._btn_upgrade.setMaximumHeight(25)
self._btn_upgrade.clicked.connect(self.on_upgrade_clicked)
# downgrade, hidden by default
self._btn_downgrade = QPushButton('', self)
self._btn_downgrade.setIcon(QIcon(':/i/arrow_down_red_16.png'))
self._btn_downgrade.setMaximumHeight(25)
self._btn_downgrade.clicked.connect(self.on_downgrade_clicked)
self._btn_downgrade.setToolTip(self.tr('Dismantle'))
self._btn_downgrade.hide()
# line edit for quantity for shipyard items, hidden by default
self._lineedit_quantity = QLineEdit(self)
self._lineedit_quantity.setMaximumWidth(50)
self._lineedit_quantity.hide()
# construct layout
# name, level
self._layout_nl.addWidget(self._lbl_name)
self._layout_nl.addWidget(self._lbl_lvl)
self._layout_nl.addStretch()
self._layout_v.addLayout(self._layout_nl)
# build time
self._layout_buildtime.addWidget(self._lbl_time)
self._layout_buildtime.addWidget(self._lbl_timestr)
self._layout_buildtime.addStretch()
self._layout_v.addLayout(self._layout_buildtime)
# price met
self._layout_price1.addWidget(self._lbl_price_met_ico)
self._layout_price1.addWidget(self._lbl_price_met)
self._layout_price1.addStretch()
# price cry
self._layout_price2.addWidget(self._lbl_price_cry_ico)
self._layout_price2.addWidget(self._lbl_price_cry)
self._layout_price2.addStretch()
# price deit
self._layout_price3.addWidget(self._lbl_price_deit_ico)
self._layout_price3.addWidget(self._lbl_price_deit)
self._layout_price3.addStretch()
# price energy
self._layout_price4.addWidget(self._lbl_price_energy_ico)
self._layout_price4.addWidget(self._lbl_price_energy)
self._layout_price4.addStretch()
self._layout_v.addLayout(self._layout_price1)
self._layout_v.addLayout(self._layout_price2)
self._layout_v.addLayout(self._layout_price3)
self._layout_v.addLayout(self._layout_price4)
# buttons
self._layout_buttons.addWidget(self._btn_upgrade)
self._layout_buttons.addWidget(self._btn_downgrade)
self._layout_buttons.addWidget(self._lineedit_quantity)
self._layout_buttons.addStretch()
self._layout_v.addLayout(self._layout_buttons)
#
self._layout.addWidget(self._lbl_pix, 0, Qt.AlignTop | Qt.AlignHCenter)
self._layout.addLayout(self._layout_v)
def set_building_item(self,
bitem: XNPlanetBuildingItem,
res_cur: XNResourceBundle,
energy_cur: int):
self._bitem = bitem
# load pixmap
pix_fn = 'ui/i/building_{0}.gif'.format(bitem.gid)
if not self._pix.load(pix_fn):
logger.warn('Failed to load pixmap from: [{0}]'.format(pix_fn))
else:
self._lbl_pix.setPixmap(self._pix.scaled(80, 80))
# self._lbl_pix.setPixmap(self._pix)
# name, level
self._lbl_name.setText(bitem.name)
if self._bitem.is_shipyard_item:
# shipyard items use quantity instead of level
self._lbl_lvl.setText(str(bitem.quantity))
else:
self._lbl_lvl.setText(str(bitem.level))
# time
if bitem.seconds_total != -1:
self._lbl_timestr.setText(time_seconds_to_str(bitem.seconds_total))
else:
self._lbl_timestr.setText('-')
# colors
color_enough = '#008800'
color_notenough = '#AA0000'
enough_met = True
enough_cry = True
enough_deit = True
enough_energy = True
# price met
if bitem.cost_met > 0:
setstr = number_format(bitem.cost_met)
color = color_enough
if res_cur.met < bitem.cost_met:
setstr += ' (-{0})'.format(number_format(
int(bitem.cost_met - res_cur.met)))
color = color_notenough
enough_met = False
self._lbl_price_met.setText('<font color="{0}">{1}</font>'.format(
color, setstr))
self._lbl_price_met_ico.show()
self._lbl_price_met.show()
else:
self._lbl_price_met_ico.hide()
self._lbl_price_met.hide()
# price cry
if bitem.cost_cry > 0:
setstr = number_format(bitem.cost_cry)
color = color_enough
if res_cur.cry < bitem.cost_cry:
setstr += ' (-{0})'.format(number_format(
int(bitem.cost_cry - res_cur.cry)))
color = color_notenough
enough_cry = False
self._lbl_price_cry.setText('<font color="{0}">{1}</font>'.format(
color, setstr))
self._lbl_price_cry_ico.show()
self._lbl_price_cry.show()
else:
self._lbl_price_cry_ico.hide()
self._lbl_price_cry.hide()
# price deit
if bitem.cost_deit > 0:
setstr = number_format(bitem.cost_deit)
color = color_enough
if res_cur.deit < bitem.cost_deit:
setstr += ' (-{0})'.format(number_format(
int(bitem.cost_deit - res_cur.deit)))
color = color_notenough
enough_deit = False
self._lbl_price_deit.setText('<font color="{0}">{1}</font>'.format(
color, setstr))
self._lbl_price_deit_ico.show()
self._lbl_price_deit.show()
else:
self._lbl_price_deit_ico.hide()
self._lbl_price_deit.hide()
# price energy
if bitem.cost_energy > 0:
setstr = number_format(bitem.cost_energy)
color = color_enough
if energy_cur < bitem.cost_energy:
setstr += ' (-{0})'.format(number_format(
int(bitem.cost_energy - energy_cur)))
color = color_notenough
enough_energy = False
self._lbl_price_energy.setText(
'<font color="{0}">{1}</font>'.format(color, setstr))
self._lbl_price_energy_ico.show()
self._lbl_price_energy.show()
else:
self._lbl_price_energy_ico.hide()
self._lbl_price_energy.hide()
#
# enable or disable buttons
if enough_met and enough_cry and enough_deit and \
enough_energy and (self._bitem.seconds_total > 0):
self._btn_upgrade.setEnabled(True)
else:
self._btn_upgrade.setEnabled(False)
# logger.debug('Disabling build {0}: {1} {2} {3} {4} {5}'.format(
# self._bitem.name, enough_met, enough_cry, enough_deit,
# enough_energy, self._bitem.seconds_total))
if self._bitem.is_building_item:
if self._bitem.level > 0:
self._btn_downgrade.setEnabled(True)
else: # nothing to downgrade
self._btn_downgrade.setEnabled(False)
# set button text
if self._bitem.is_shipyard_item:
self._btn_upgrade.setText(self.tr('Build'))
# calculate maximum available to build
counts = [0, 0, 0, 0]
# check metal cost
if self._bitem.cost_met > 0:
counts[0] = int(res_cur.met // self._bitem.cost_met)
# check crystal cost
if self._bitem.cost_cry > 0:
counts[1] = int(res_cur.cry // self._bitem.cost_cry)
# check deit cost
if self._bitem.cost_deit > 0:
counts[2] = int(res_cur.deit // self._bitem.cost_deit)
# check energy
if self._bitem.cost_energy > 0:
counts[3] = int(energy_cur // self._bitem.cost_energy)
maxb = 0
for cnt in counts: # find first count, which is > 0
if cnt > 0:
maxb = cnt
break
for cnt in counts: # find minimum count, which is > 0
if cnt > 0:
if cnt < maxb:
maxb = cnt
# set tip
self._lineedit_quantity.setPlaceholderText(str(maxb))
elif self._bitem.is_research_item or self._bitem.is_researchfleet_item:
self._btn_upgrade.setText(self.tr('Research'))
# show/hide additional buttons
if self._bitem.is_building_item:
self._btn_upgrade.show()
self._btn_downgrade.show()
self._lineedit_quantity.hide()
elif self._bitem.is_shipyard_item:
self._btn_upgrade.show()
self._btn_downgrade.hide()
self._lineedit_quantity.show()
elif self._bitem.is_research_item or self._bitem.is_researchfleet_item:
self._btn_upgrade.show()
self._btn_downgrade.hide()
self._lineedit_quantity.hide()
@pyqtSlot()
def on_upgrade_clicked(self):
if not self._bitem.is_shipyard_item:
# all buildings and researches, quantity is ignored (send 1)
self.requestBuildItem.emit(self._bitem, 1)
else:
# shipyard build item case, read also quantity
qtext = self._lineedit_quantity.text()
qint = -1
try:
qint = int(qtext)
except ValueError:
pass
if qint < 1: # invalid format
QMessageBox.warning(self,
self.tr('Invalid format!'),
self.tr('Please input positive integer value!'))
return
# clear lineedit text
self._lineedit_quantity.setText('')
# emit with qint as quantity
self.requestBuildItem.emit(self._bitem, qint)
@pyqtSlot()
def on_downgrade_clicked(self):
self.requestDowngradeItem.emit(self._bitem)
class PixmapDial(QDial):
# enum CustomPaintMode
CUSTOM_PAINT_MODE_NULL = 0 # default (NOTE: only this mode has label gradient)
CUSTOM_PAINT_MODE_CARLA_WET = 1 # color blue-green gradient (reserved #3)
CUSTOM_PAINT_MODE_CARLA_VOL = 2 # color blue (reserved #3)
CUSTOM_PAINT_MODE_CARLA_L = 3 # color yellow (reserved #4)
CUSTOM_PAINT_MODE_CARLA_R = 4 # color yellow (reserved #4)
CUSTOM_PAINT_MODE_CARLA_PAN = 5 # color yellow (reserved #3)
CUSTOM_PAINT_MODE_COLOR = 6 # color, selectable (reserved #3)
CUSTOM_PAINT_MODE_ZITA = 7 # custom zita knob (reserved #6)
CUSTOM_PAINT_MODE_NO_GRADIENT = 8 # skip label gradient
# enum Orientation
HORIZONTAL = 0
VERTICAL = 1
HOVER_MIN = 0
HOVER_MAX = 9
MODE_DEFAULT = 0
MODE_LINEAR = 1
# signals
realValueChanged = pyqtSignal(float)
def __init__(self, parent, index=0):
QDial.__init__(self, parent)
self.fDialMode = self.MODE_LINEAR
self.fMinimum = 0.0
self.fMaximum = 1.0
self.fRealValue = 0.0
self.fPrecision = 10000
self.fIsInteger = False
self.fIsHovered = False
self.fIsPressed = False
self.fHoverStep = self.HOVER_MIN
self.fLastDragPos = None
self.fLastDragValue = 0.0
self.fIndex = index
self.fPixmap = QPixmap(":/bitmaps/dial_01d.png")
self.fPixmapNum = "01"
if self.fPixmap.width() > self.fPixmap.height():
self.fPixmapOrientation = self.HORIZONTAL
else:
self.fPixmapOrientation = self.VERTICAL
self.fLabel = ""
self.fLabelPos = QPointF(0.0, 0.0)
self.fLabelFont = QFont(self.font())
self.fLabelFont.setPixelSize(8)
self.fLabelWidth = 0
self.fLabelHeight = 0
if self.palette().window().color().lightness() > 100:
# Light background
c = self.palette().dark().color()
self.fLabelGradientColor1 = c
self.fLabelGradientColor2 = QColor(c.red(), c.green(), c.blue(), 0)
self.fLabelGradientColorT = [self.palette().buttonText().color(), self.palette().mid().color()]
else:
# Dark background
self.fLabelGradientColor1 = QColor(0, 0, 0, 255)
self.fLabelGradientColor2 = QColor(0, 0, 0, 0)
self.fLabelGradientColorT = [Qt.white, Qt.darkGray]
self.fLabelGradient = QLinearGradient(0, 0, 0, 1)
self.fLabelGradient.setColorAt(0.0, self.fLabelGradientColor1)
self.fLabelGradient.setColorAt(0.6, self.fLabelGradientColor1)
self.fLabelGradient.setColorAt(1.0, self.fLabelGradientColor2)
self.fLabelGradientRect = QRectF(0.0, 0.0, 0.0, 0.0)
self.fCustomPaintMode = self.CUSTOM_PAINT_MODE_NULL
self.fCustomPaintColor = QColor(0xff, 0xff, 0xff)
self.updateSizes()
# Fake internal value, custom precision
QDial.setMinimum(self, 0)
QDial.setMaximum(self, self.fPrecision)
QDial.setValue(self, 0)
self.valueChanged.connect(self.slot_valueChanged)
def getIndex(self):
return self.fIndex
def getBaseSize(self):
return self.fPixmapBaseSize
def forceWhiteLabelGradientText(self):
self.fLabelGradientColor1 = QColor(0, 0, 0, 255)
self.fLabelGradientColor2 = QColor(0, 0, 0, 0)
self.fLabelGradientColorT = [Qt.white, Qt.darkGray]
def setLabelColor(self, enabled, disabled):
self.fLabelGradientColor1 = QColor(0, 0, 0, 255)
self.fLabelGradientColor2 = QColor(0, 0, 0, 0)
self.fLabelGradientColorT = [enabled, disabled]
def updateSizes(self):
self.fPixmapWidth = self.fPixmap.width()
self.fPixmapHeight = self.fPixmap.height()
if self.fPixmapWidth < 1:
self.fPixmapWidth = 1
if self.fPixmapHeight < 1:
self.fPixmapHeight = 1
if self.fPixmapOrientation == self.HORIZONTAL:
self.fPixmapBaseSize = self.fPixmapHeight
self.fPixmapLayersCount = self.fPixmapWidth / self.fPixmapHeight
else:
self.fPixmapBaseSize = self.fPixmapWidth
self.fPixmapLayersCount = self.fPixmapHeight / self.fPixmapWidth
self.setMinimumSize(self.fPixmapBaseSize, self.fPixmapBaseSize + self.fLabelHeight + 5)
self.setMaximumSize(self.fPixmapBaseSize, self.fPixmapBaseSize + self.fLabelHeight + 5)
if not self.fLabel:
self.fLabelHeight = 0
self.fLabelWidth = 0
return
self.fLabelWidth = QFontMetrics(self.fLabelFont).width(self.fLabel)
self.fLabelHeight = QFontMetrics(self.fLabelFont).height()
self.fLabelPos.setX(float(self.fPixmapBaseSize)/2.0 - float(self.fLabelWidth)/2.0)
if self.fPixmapNum in ("01", "02", "07", "08", "09", "10"):
self.fLabelPos.setY(self.fPixmapBaseSize + self.fLabelHeight)
elif self.fPixmapNum in ("11",):
self.fLabelPos.setY(self.fPixmapBaseSize + self.fLabelHeight*2/3)
else:
self.fLabelPos.setY(self.fPixmapBaseSize + self.fLabelHeight/2)
self.fLabelGradient.setStart(0, float(self.fPixmapBaseSize)/2.0)
self.fLabelGradient.setFinalStop(0, self.fPixmapBaseSize + self.fLabelHeight + 5)
self.fLabelGradientRect = QRectF(float(self.fPixmapBaseSize)/8.0, float(self.fPixmapBaseSize)/2.0, float(self.fPixmapBaseSize*3)/4.0, self.fPixmapBaseSize+self.fLabelHeight+5)
def setCustomPaintMode(self, paintMode):
if self.fCustomPaintMode == paintMode:
return
self.fCustomPaintMode = paintMode
self.update()
def setCustomPaintColor(self, color):
if self.fCustomPaintColor == color:
return
self.fCustomPaintColor = color
self.update()
def setLabel(self, label):
if self.fLabel == label:
return
self.fLabel = label
self.updateSizes()
self.update()
def setIndex(self, index):
self.fIndex = index
def setPixmap(self, pixmapId):
self.fPixmapNum = "%02i" % pixmapId
self.fPixmap.load(":/bitmaps/dial_%s%s.png" % (self.fPixmapNum, "" if self.isEnabled() else "d"))
if self.fPixmap.width() > self.fPixmap.height():
self.fPixmapOrientation = self.HORIZONTAL
else:
self.fPixmapOrientation = self.VERTICAL
# special pixmaps
if self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_NULL:
# reserved for carla-wet, carla-vol, carla-pan and color
if self.fPixmapNum == "03":
self.fCustomPaintMode = self.CUSTOM_PAINT_MODE_COLOR
# reserved for carla-L and carla-R
elif self.fPixmapNum == "04":
self.fCustomPaintMode = self.CUSTOM_PAINT_MODE_CARLA_L
# reserved for zita
elif self.fPixmapNum == "06":
self.fCustomPaintMode = self.CUSTOM_PAINT_MODE_ZITA
self.updateSizes()
self.update()
def setPrecision(self, value, isInteger):
self.fPrecision = value
self.fIsInteger = isInteger
QDial.setMaximum(self, value)
def setMinimum(self, value):
self.fMinimum = value
def setMaximum(self, value):
self.fMaximum = value
def setValue(self, value, emitSignal=False):
if self.fRealValue == value:
return
if value <= self.fMinimum:
qtValue = 0
self.fRealValue = self.fMinimum
elif value >= self.fMaximum:
qtValue = self.fPrecision
self.fRealValue = self.fMaximum
else:
qtValue = round(float(value - self.fMinimum) / float(self.fMaximum - self.fMinimum) * self.fPrecision)
self.fRealValue = value
# Block change signal, we'll handle it ourselves
self.blockSignals(True)
QDial.setValue(self, qtValue)
self.blockSignals(False)
if emitSignal:
self.realValueChanged.emit(self.fRealValue)
@pyqtSlot(int)
def slot_valueChanged(self, value):
self.fRealValue = float(value)/self.fPrecision * (self.fMaximum - self.fMinimum) + self.fMinimum
self.realValueChanged.emit(self.fRealValue)
@pyqtSlot()
def slot_updatePixmap(self):
self.setPixmap(int(self.fPixmapNum))
def minimumSizeHint(self):
return QSize(self.fPixmapBaseSize, self.fPixmapBaseSize)
def sizeHint(self):
return QSize(self.fPixmapBaseSize, self.fPixmapBaseSize)
def changeEvent(self, event):
QDial.changeEvent(self, event)
# Force pixmap update if enabled state changes
if event.type() == QEvent.EnabledChange:
self.setPixmap(int(self.fPixmapNum))
def enterEvent(self, event):
self.fIsHovered = True
if self.fHoverStep == self.HOVER_MIN:
self.fHoverStep = self.HOVER_MIN + 1
QDial.enterEvent(self, event)
def leaveEvent(self, event):
self.fIsHovered = False
if self.fHoverStep == self.HOVER_MAX:
self.fHoverStep = self.HOVER_MAX - 1
QDial.leaveEvent(self, event)
def mousePressEvent(self, event):
if self.fDialMode == self.MODE_DEFAULT:
return QDial.mousePressEvent(self, event)
if event.button() == Qt.LeftButton:
self.fIsPressed = True
self.fLastDragPos = event.pos()
self.fLastDragValue = self.fRealValue
def mouseMoveEvent(self, event):
if self.fDialMode == self.MODE_DEFAULT:
return QDial.mouseMoveEvent(self, event)
if not self.fIsPressed:
return
range = (self.fMaximum - self.fMinimum) / 4.0
pos = event.pos()
dx = range * float(pos.x() - self.fLastDragPos.x()) / self.width()
dy = range * float(pos.y() - self.fLastDragPos.y()) / self.height()
value = self.fLastDragValue + dx - dy
if value < self.fMinimum:
value = self.fMinimum
elif value > self.fMaximum:
value = self.fMaximum
elif self.fIsInteger:
value = float(round(value))
self.setValue(value, True)
def mouseReleaseEvent(self, event):
if self.fDialMode == self.MODE_DEFAULT:
return QDial.mouseReleaseEvent(self, event)
if self.fIsPressed:
self.fIsPressed = False
def paintEvent(self, event):
painter = QPainter(self)
event.accept()
painter.save()
painter.setRenderHint(QPainter.Antialiasing, True)
if self.fLabel:
if self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_NULL:
painter.setPen(self.fLabelGradientColor2)
painter.setBrush(self.fLabelGradient)
painter.drawRect(self.fLabelGradientRect)
painter.setFont(self.fLabelFont)
painter.setPen(self.fLabelGradientColorT[0 if self.isEnabled() else 1])
painter.drawText(self.fLabelPos, self.fLabel)
if self.isEnabled():
normValue = float(self.fRealValue - self.fMinimum) / float(self.fMaximum - self.fMinimum)
target = QRectF(0.0, 0.0, self.fPixmapBaseSize, self.fPixmapBaseSize)
curLayer = int((self.fPixmapLayersCount - 1) * normValue)
if self.fPixmapOrientation == self.HORIZONTAL:
xpos = self.fPixmapBaseSize * curLayer
ypos = 0.0
else:
xpos = 0.0
ypos = self.fPixmapBaseSize * curLayer
source = QRectF(xpos, ypos, self.fPixmapBaseSize, self.fPixmapBaseSize)
painter.drawPixmap(target, self.fPixmap, source)
# Custom knobs (Dry/Wet and Volume)
if self.fCustomPaintMode in (self.CUSTOM_PAINT_MODE_CARLA_WET, self.CUSTOM_PAINT_MODE_CARLA_VOL):
# knob color
colorGreen = QColor(0x5D, 0xE7, 0x3D).lighter(100 + self.fHoverStep*6)
colorBlue = QColor(0x3E, 0xB8, 0xBE).lighter(100 + self.fHoverStep*6)
# draw small circle
ballRect = QRectF(8.0, 8.0, 15.0, 15.0)
ballPath = QPainterPath()
ballPath.addEllipse(ballRect)
#painter.drawRect(ballRect)
tmpValue = (0.375 + 0.75*normValue)
ballValue = tmpValue - floor(tmpValue)
ballPoint = ballPath.pointAtPercent(ballValue)
# draw arc
startAngle = 216*16
spanAngle = -252*16*normValue
if self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_CARLA_WET:
painter.setBrush(colorBlue)
painter.setPen(QPen(colorBlue, 0))
painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.2, 2.2))
gradient = QConicalGradient(15.5, 15.5, -45)
gradient.setColorAt(0.0, colorBlue)
gradient.setColorAt(0.125, colorBlue)
gradient.setColorAt(0.625, colorGreen)
gradient.setColorAt(0.75, colorGreen)
gradient.setColorAt(0.76, colorGreen)
gradient.setColorAt(1.0, colorGreen)
painter.setBrush(gradient)
painter.setPen(QPen(gradient, 3))
else:
painter.setBrush(colorBlue)
painter.setPen(QPen(colorBlue, 0))
painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.2, 2.2))
painter.setBrush(colorBlue)
painter.setPen(QPen(colorBlue, 3))
painter.drawArc(4.0, 4.0, 26.0, 26.0, startAngle, spanAngle)
# Custom knobs (L and R)
elif self.fCustomPaintMode in (self.CUSTOM_PAINT_MODE_CARLA_L, self.CUSTOM_PAINT_MODE_CARLA_R):
# knob color
color = QColor(0xAD, 0xD5, 0x48).lighter(100 + self.fHoverStep*6)
# draw small circle
ballRect = QRectF(7.0, 8.0, 11.0, 12.0)
ballPath = QPainterPath()
ballPath.addEllipse(ballRect)
#painter.drawRect(ballRect)
tmpValue = (0.375 + 0.75*normValue)
ballValue = tmpValue - floor(tmpValue)
ballPoint = ballPath.pointAtPercent(ballValue)
painter.setBrush(color)
painter.setPen(QPen(color, 0))
painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.0, 2.0))
# draw arc
if self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_CARLA_L:
startAngle = 216*16
spanAngle = -252.0*16*normValue
else:
startAngle = 324.0*16
spanAngle = 252.0*16*(1.0-normValue)
painter.setPen(QPen(color, 2))
painter.drawArc(3.5, 4.5, 22.0, 22.0, startAngle, spanAngle)
# Custom knobs (Color)
elif self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_COLOR:
# knob color
color = self.fCustomPaintColor.lighter(100 + self.fHoverStep*6)
# draw small circle
ballRect = QRectF(8.0, 8.0, 15.0, 15.0)
ballPath = QPainterPath()
ballPath.addEllipse(ballRect)
tmpValue = (0.375 + 0.75*normValue)
ballValue = tmpValue - floor(tmpValue)
ballPoint = ballPath.pointAtPercent(ballValue)
# draw arc
startAngle = 216*16
spanAngle = -252*16*normValue
painter.setBrush(color)
painter.setPen(QPen(color, 0))
painter.drawEllipse(QRectF(ballPoint.x(), ballPoint.y(), 2.2, 2.2))
painter.setBrush(color)
painter.setPen(QPen(color, 3))
painter.drawArc(4.0, 4.0, 26.0, 26.0, startAngle, spanAngle)
# Custom knobs (Zita)
elif self.fCustomPaintMode == self.CUSTOM_PAINT_MODE_ZITA:
a = normValue * pi * 1.5 - 2.35
r = 10.0
x = 10.5
y = 10.5
x += r * sin(a)
y -= r * cos(a)
painter.setBrush(Qt.black)
painter.setPen(QPen(Qt.black, 2))
painter.drawLine(QPointF(11.0, 11.0), QPointF(x, y))
# Custom knobs
else:
painter.restore()
return
if self.HOVER_MIN < self.fHoverStep < self.HOVER_MAX:
self.fHoverStep += 1 if self.fIsHovered else -1
QTimer.singleShot(20, self.update)
else: # isEnabled()
target = QRectF(0.0, 0.0, self.fPixmapBaseSize, self.fPixmapBaseSize)
painter.drawPixmap(target, self.fPixmap, target)
painter.restore()
def resizeEvent(self, event):
QDial.resizeEvent(self, event)
self.updateSizes()
class Player(QWidget):
grid = QGridLayout()
def __init__(self):
super().__init__()
self.instance = vlc.Instance()
self.mediaplayer = self.instance.media_player_new()
self.initUI()
def initUI(self):
self.setWindowTitle('RandomVK')
self.setWindowIcon(QIcon('web.png'))
self.Author_Label = QLabel()
self.Name_Label = QLabel()
self.Add_Button = QPushButton('Add')
self.Add_Button.clicked.connect(self.Click_Add)
self.PP_Button = QPushButton('Play')
self.PP_Button.clicked.connect(self.Click_PP)
self.Next_Button = QPushButton('Next')
self.Next_Button.clicked.connect(self.Click_Next)
self.Song_Image_Label = QLabel(self)
self.Song_Image = QPixmap('blank.png')
self.Song_Image_Label.setPixmap(self.Song_Image)
self.Cost_Label = QLabel('-')
self.grid.setSpacing(9)
self.grid.addWidget(self.Song_Image_Label, 0, 1)
self.grid.addWidget(self.Author_Label, 1, 0)
self.grid.addWidget(self.Cost_Label, 1, 1)
self.grid.addWidget(self.Name_Label, 1, 2)
self.grid.addWidget(self.Add_Button, 2, 0)
self.grid.addWidget(self.Next_Button, 2, 2)
self.grid.addWidget(self.PP_Button, 2, 1)
self.setLayout(self.grid)
def Click_Next(self):
self.audio = vk.get_audio()
temp = tempfile.gettempdir()
if os.name == 'nt':
temp += '\\RandomVK'
else:
temp += '/RandomVK'
if not os.path.exists(temp):
os.mkdir(temp)
resp = backend.requests.get(self.audio['url'])
if 'image' in self.audio:
img = backend.requests.get(self.audio['image'])
else:
self.Song_Image.load('blank.png')
if os.name == 'nt':
tempfile_rand = open(temp + '\\temp.mp3', 'wb')
tempfile_rand.write(resp.content)
tempfile_rand.close()
self.media = self.instance.media_new(temp + '\\temp.mp3')
if 'image' in self.audio:
tmp_image = open(temp + '\\temp.png', 'wb')
tmp_image.write(img.content)
tmp_image.close()
self.Song_Image.load(temp + '\\temp.png')
else:
tempfile_rand = open(temp + '/temp.mp3', 'wb')
tempfile_rand.write(resp.content)
tempfile_rand.close()
self.media = self.instance.media_new(temp + '/temp.mp3')
if 'image' in self.audio:
tmp_image = open(temp + '/temp.png', 'wb')
tmp_image.write(img.content)
tmp_image.close()
self.Song_Image.load(temp + '/temp.png')
try:
self.mediaplayer.stop()
except:
pass
self.Song_Image_Label.setPixmap(self.Song_Image)
self.mediaplayer.set_media(self.media)
self.mediaplayer.play()
self.time_last = time.time()
self.PP_Button.setText('Pause')
self.Author_Label.setText(self.audio['artist'])
self.Name_Label.setText(self.audio['title'])
self.thread = threading.Thread(target=self.th)
self.thread.daemon = True
self.thread.start()
def Click_Add(self):
global vk
vk.add(self.audio['id'], self.audio['aid'])
def Click_PP(self):
if self.mediaplayer.is_playing():
self.mediaplayer.pause()
self.PP_Button.setText("Play")
self.time_last = time.time()
del self.thread
else:
self.mediaplayer.play()
self.time_last -= time.time()
self.audio['duration'] -= int(self.time_last)
self.audio['duration'] *= -1
self.audio['duration'] += 15
self.PP_Button.setText('Pause')
self.thread = threading.Thread(target=self.th)
self.thread.daemon = True
self.thread.start()
def th(self):
time.sleep(int(self.audio['duration']))
def pixmap(self):
p = QPixmap()
if self.value != Orb.Null:
p.load('orbs/%s.png' % str(self.value))
#p = p.scaled(40,40,1)
return p
class PixmapKeyboard(QWidget):
# enum Orientation
HORIZONTAL = 0
VERTICAL = 1
# signals
noteOn = pyqtSignal(int)
noteOff = pyqtSignal(int)
notesOn = pyqtSignal()
notesOff = pyqtSignal()
def __init__(self, parent):
QWidget.__init__(self, parent)
self.fOctaves = 6
self.fLastMouseNote = -1
self.fEnabledKeys = []
self.fFont = self.font()
self.fFont.setFamily("Monospace")
self.fFont.setPixelSize(12)
self.fFont.setBold(True)
self.fPixmap = QPixmap("")
self.setCursor(Qt.PointingHandCursor)
self.setMode(self.HORIZONTAL)
def allNotesOff(self, sendSignal=True):
self.fEnabledKeys = []
if sendSignal:
self.notesOff.emit()
self.update()
def sendNoteOn(self, note, sendSignal=True):
if 0 <= note <= 127 and note not in self.fEnabledKeys:
self.fEnabledKeys.append(note)
if sendSignal:
self.noteOn.emit(note)
self.update()
if len(self.fEnabledKeys) == 1:
self.notesOn.emit()
def sendNoteOff(self, note, sendSignal=True):
if 0 <= note <= 127 and note in self.fEnabledKeys:
self.fEnabledKeys.remove(note)
if sendSignal:
self.noteOff.emit(note)
self.update()
if len(self.fEnabledKeys) == 0:
self.notesOff.emit()
def setMode(self, mode):
if mode == self.HORIZONTAL:
self.fMidiMap = kMidiKey2RectMapHorizontal
self.fPixmap.load(":/bitmaps/kbd_h_dark.png")
self.fPixmapMode = self.HORIZONTAL
self.fWidth = self.fPixmap.width()
self.fHeight = self.fPixmap.height() / 2
elif mode == self.VERTICAL:
self.fMidiMap = kMidiKey2RectMapVertical
self.fPixmap.load(":/bitmaps/kbd_v_dark.png")
self.fPixmapMode = self.VERTICAL
self.fWidth = self.fPixmap.width() / 2
self.fHeight = self.fPixmap.height()
else:
qCritical("PixmapKeyboard::setMode(%i) - invalid mode" % mode)
return self.setMode(self.HORIZONTAL)
self.setOctaves(self.fOctaves)
def setOctaves(self, octaves):
if octaves < 1:
octaves = 1
elif octaves > 10:
octaves = 10
self.fOctaves = octaves
if self.fPixmapMode == self.HORIZONTAL:
self.setMinimumSize(self.fWidth * self.fOctaves, self.fHeight)
self.setMaximumSize(self.fWidth * self.fOctaves, self.fHeight)
elif self.fPixmapMode == self.VERTICAL:
self.setMinimumSize(self.fWidth, self.fHeight * self.fOctaves)
self.setMaximumSize(self.fWidth, self.fHeight * self.fOctaves)
self.update()
def handleMousePos(self, pos):
if self.fPixmapMode == self.HORIZONTAL:
if pos.x() < 0 or pos.x() > self.fOctaves * self.fWidth:
return
octave = int(pos.x() / self.fWidth)
keyPos = QPointF(pos.x() % self.fWidth, pos.y())
elif self.fPixmapMode == self.VERTICAL:
if pos.y() < 0 or pos.y() > self.fOctaves * self.fHeight:
return
octave = int(self.fOctaves - pos.y() / self.fHeight)
keyPos = QPointF(pos.x(), (pos.y()-1) % self.fHeight)
else:
return
if self.fMidiMap['1'].contains(keyPos): # C#
note = 1
elif self.fMidiMap['3'].contains(keyPos): # D#
note = 3
elif self.fMidiMap['6'].contains(keyPos): # F#
note = 6
elif self.fMidiMap['8'].contains(keyPos): # G#
note = 8
elif self.fMidiMap['10'].contains(keyPos):# A#
note = 10
elif self.fMidiMap['0'].contains(keyPos): # C
note = 0
elif self.fMidiMap['2'].contains(keyPos): # D
note = 2
elif self.fMidiMap['4'].contains(keyPos): # E
note = 4
elif self.fMidiMap['5'].contains(keyPos): # F
note = 5
elif self.fMidiMap['7'].contains(keyPos): # G
note = 7
elif self.fMidiMap['9'].contains(keyPos): # A
note = 9
elif self.fMidiMap['11'].contains(keyPos):# B
note = 11
else:
note = -1
if note != -1:
note += octave * 12
if self.fLastMouseNote != note:
self.sendNoteOff(self.fLastMouseNote)
self.sendNoteOn(note)
elif self.fLastMouseNote != -1:
self.sendNoteOff(self.fLastMouseNote)
self.fLastMouseNote = note
def minimumSizeHint(self):
return QSize(self.fWidth, self.fHeight)
def sizeHint(self):
if self.fPixmapMode == self.HORIZONTAL:
return QSize(self.fWidth * self.fOctaves, self.fHeight)
elif self.fPixmapMode == self.VERTICAL:
return QSize(self.fWidth, self.fHeight * self.fOctaves)
else:
return QSize(self.fWidth, self.fHeight)
def keyPressEvent(self, event):
if not event.isAutoRepeat():
qKey = str(event.key())
if qKey in kMidiKeyboard2KeyMap.keys():
self.sendNoteOn(kMidiKeyboard2KeyMap.get(qKey))
QWidget.keyPressEvent(self, event)
def keyReleaseEvent(self, event):
if not event.isAutoRepeat():
qKey = str(event.key())
if qKey in kMidiKeyboard2KeyMap.keys():
self.sendNoteOff(kMidiKeyboard2KeyMap.get(qKey))
QWidget.keyReleaseEvent(self, event)
def mousePressEvent(self, event):
self.fLastMouseNote = -1
self.handleMousePos(event.pos())
self.setFocus()
QWidget.mousePressEvent(self, event)
def mouseMoveEvent(self, event):
self.handleMousePos(event.pos())
QWidget.mouseMoveEvent(self, event)
def mouseReleaseEvent(self, event):
if self.fLastMouseNote != -1:
self.sendNoteOff(self.fLastMouseNote)
self.fLastMouseNote = -1
QWidget.mouseReleaseEvent(self, event)
def paintEvent(self, event):
painter = QPainter(self)
event.accept()
# -------------------------------------------------------------
# Paint clean keys (as background)
for octave in range(self.fOctaves):
if self.fPixmapMode == self.HORIZONTAL:
target = QRectF(self.fWidth * octave, 0, self.fWidth, self.fHeight)
elif self.fPixmapMode == self.VERTICAL:
target = QRectF(0, self.fHeight * octave, self.fWidth, self.fHeight)
else:
return
source = QRectF(0, 0, self.fWidth, self.fHeight)
painter.drawPixmap(target, self.fPixmap, source)
if not self.isEnabled():
painter.setBrush(QColor(0, 0, 0, 150))
painter.setPen(QColor(0, 0, 0, 150))
painter.drawRect(0, 0, self.width(), self.height())
return
# -------------------------------------------------------------
# Paint (white) pressed keys
paintedWhite = False
for note in self.fEnabledKeys:
pos = self._getRectFromMidiNote(note)
if self._isNoteBlack(note):
continue
if note < 12:
octave = 0
elif note < 24:
octave = 1
elif note < 36:
octave = 2
elif note < 48:
octave = 3
elif note < 60:
octave = 4
elif note < 72:
octave = 5
elif note < 84:
octave = 6
elif note < 96:
octave = 7
elif note < 108:
octave = 8
elif note < 120:
octave = 9
elif note < 132:
octave = 10
else:
# cannot paint this note
continue
if self.fPixmapMode == self.VERTICAL:
octave = self.fOctaves - octave - 1
if self.fPixmapMode == self.HORIZONTAL:
target = QRectF(pos.x() + (self.fWidth * octave), 0, pos.width(), pos.height())
source = QRectF(pos.x(), self.fHeight, pos.width(), pos.height())
elif self.fPixmapMode == self.VERTICAL:
target = QRectF(pos.x(), pos.y() + (self.fHeight * octave), pos.width(), pos.height())
source = QRectF(self.fWidth, pos.y(), pos.width(), pos.height())
else:
return
paintedWhite = True
painter.drawPixmap(target, self.fPixmap, source)
# -------------------------------------------------------------
# Clear white keys border
if paintedWhite:
for octave in range(self.fOctaves):
for note in kBlackNotes:
pos = self._getRectFromMidiNote(note)
if self.fPixmapMode == self.HORIZONTAL:
target = QRectF(pos.x() + (self.fWidth * octave), 0, pos.width(), pos.height())
source = QRectF(pos.x(), 0, pos.width(), pos.height())
elif self.fPixmapMode == self.VERTICAL:
target = QRectF(pos.x(), pos.y() + (self.fHeight * octave), pos.width(), pos.height())
source = QRectF(0, pos.y(), pos.width(), pos.height())
else:
return
painter.drawPixmap(target, self.fPixmap, source)
# -------------------------------------------------------------
# Paint (black) pressed keys
for note in self.fEnabledKeys:
pos = self._getRectFromMidiNote(note)
if not self._isNoteBlack(note):
continue
if note < 12:
octave = 0
elif note < 24:
octave = 1
elif note < 36:
octave = 2
elif note < 48:
octave = 3
elif note < 60:
octave = 4
elif note < 72:
octave = 5
elif note < 84:
octave = 6
elif note < 96:
octave = 7
elif note < 108:
octave = 8
elif note < 120:
octave = 9
elif note < 132:
octave = 10
else:
# cannot paint this note
continue
if self.fPixmapMode == self.VERTICAL:
octave = self.fOctaves - octave - 1
if self.fPixmapMode == self.HORIZONTAL:
target = QRectF(pos.x() + (self.fWidth * octave), 0, pos.width(), pos.height())
source = QRectF(pos.x(), self.fHeight, pos.width(), pos.height())
elif self.fPixmapMode == self.VERTICAL:
target = QRectF(pos.x(), pos.y() + (self.fHeight * octave), pos.width(), pos.height())
source = QRectF(self.fWidth, pos.y(), pos.width(), pos.height())
else:
return
painter.drawPixmap(target, self.fPixmap, source)
# Paint C-number note info
painter.setFont(self.fFont)
painter.setPen(Qt.black)
for i in range(self.fOctaves):
if self.fPixmapMode == self.HORIZONTAL:
painter.drawText(i * 168 + (4 if i == 0 else 3), 35, 20, 20, Qt.AlignCenter, "C%i" % (i-1))
elif self.fPixmapMode == self.VERTICAL:
painter.drawText(33, (self.fOctaves * 168) - (i * 168) - 20, 20, 20, Qt.AlignCenter, "C%i" % (i-1))
def _isNoteBlack(self, note):
baseNote = note % 12
return bool(baseNote in kBlackNotes)
def _getRectFromMidiNote(self, note):
baseNote = note % 12
return self.fMidiMap.get(str(baseNote))
class Ground(QLabel):
def __init__(self, parent):
QLabel.__init__(self, parent)
self.symbol = QPixmap()
self.symbol.load('gnd.png')
self.symbol = self.symbol.scaledToWidth(30)
self.resize(self.symbol.size())
self.setPixmap(self.symbol)
self.move(300, 300)
self.show()
self.Node = node(parent)
self.Node.move(self.x() + 10, self.y())
self.Node.id = 'N0'
self.Node.show()
self.parent().node_dict['N0'].add(self)
# When right click on element a menu pops on
self.PropMenu = QMenu(parent)
# self.PropMenu.addAction('Rotate')
self.PropMenu.addAction('Delete')
# Setting Geometry of menu
self.PropMenu.move(parent.frameGeometry().left() + self.x() + 30,
parent.frameGeometry().top() + self.y() + 30)
def mousePressEvent(self, event):
self.__mousePressPos = None
self.__mouseMovePos = None
if event.button() == QtCore.Qt.LeftButton:
self.__mousePressPos = event.globalPos()
self.__mouseMovePos = event.globalPos()
if event.button() == QtCore.Qt.RightButton:
action = self.PropMenu.exec()
if action is not None:
if action.text() == 'Delete':
print('Delete clicked')
self.deleteMe()
# elif action.text() == 'Rotate':
# print('Rotate clicked')
# # self.Rotate()
super(Ground, self).mousePressEvent(event)
def mouseMoveEvent(self, event):
if event.buttons() == QtCore.Qt.LeftButton:
# adjust offset from clicked point to origin of widget
currPos = self.mapToGlobal(self.pos())
globalPos = event.globalPos()
diff = globalPos - self.__mouseMovePos
newPos = self.mapFromGlobal(currPos + diff)
# Moving element to new position
self.move(newPos)
self.Node.move(newPos.x() + 10, newPos.y() )
self.PropMenu.move(self.parent().frameGeometry().left() + newPos.x() + 30,
self.parent().frameGeometry().top() + newPos.y() + 30)
self.__mouseMovePos = globalPos
super(Ground, self).mouseMoveEvent(event)
def mouseReleaseEvent(self, event):
if self.__mousePressPos is not None:
moved = event.globalPos() - self.__mousePressPos
if moved.manhattanLength() > 3:
event.ignore()
return
super(Ground, self).mouseReleaseEvent(event)
def deleteMe(self):
self.hide()
self.Node.hide()
class Inductor(element):
def __init__(self, name, parent, value = 0.01):
element.__init__(self, name, parent, value)
self.Impedance = 1j *2 * np.pi * Current_src.freq * self.value
# adding image to resistor(that is a QLabel object itself) as its symbol
self.symbol = QPixmap()
self.symbol.load('ind.png')
self.symbol = self.symbol.scaledToWidth(100)
self.resize(self.symbol.size())
self.setPixmap(self.symbol)
self.move(200, 100)
self.valueText = QLineEdit(parent)
self.valueText.move(self.x() + 30, self.y() + 40)
self.valueText.resize(50, 15)
self.valueText.setText(str(self.value) + ' H')
self.idLabel = QLabel(parent)
self.idLabel.move(self.x() + 45, self.y())
self.idLabel.resize(20, 15)
self.idLabel.setText(str(self.name))
self.idLabel.show()
self.nodeP = node(parent)
self.nodeS = node(parent)
self.nodeP.move(self.x(), self.y() + 22)
self.nodeS.move(self.x() + 90, self.y() + 22)
self.nodeP.show()
self.nodeS.show()
# first element tahr is connected to a ned is It's element.
self.nodeP.connected_elements.add(self.name)
self.nodeS.connected_elements.add(self.name)
# When right click on element a menu pops on
self.PropMenu = QMenu(parent)
self.PropMenu.addAction('Change Value')
self.PropMenu.addAction('Rotate')
self.PropMenu.addAction('Delete')
# Setting Geometry of menu
self.PropMenu.move(parent.frameGeometry().left() + self.x() + 20,
parent.frameGeometry().top() + self.y() + 100)
self.isHorizontal = True
self.direction_label = QLabel(parent)
self.direction = QPixmap()
self.valueText.show()
self.show()
def mousePressEvent(self, event):
self.__mousePressPos = None
self.__mouseMovePos = None
if event.button() == QtCore.Qt.LeftButton:
self.__mousePressPos = event.globalPos()
self.__mouseMovePos = event.globalPos()
if event.button() == QtCore.Qt.RightButton:
action = self.PropMenu.exec()
if action is not None:
if action.text() == 'Change Value':
print('Change Value clicked')
self.value = float(re.match('\d*(?:.\d*e?-?\d*)?', self.valueText.text()).group())
self.Impedance = 1j *2 * np.pi * Current_src.freq * self.value
elif action.text() == 'Rotate':
print('Rotate clicked')
self.Rotate()
elif action.text() == 'Delete':
print('Delete clicked')
self.deleteMe()
self.parent().elements.remove(self)
super(Inductor, self).mousePressEvent(event)
def mouseMoveEvent(self, event):
if event.buttons() == QtCore.Qt.LeftButton:
# adjust offset from clicked point to origin of widget
currPos = self.mapToGlobal(self.pos())
globalPos = event.globalPos()
diff = globalPos - self.__mouseMovePos
newPos = self.mapFromGlobal(currPos + diff)
# Moving element to new position
self.move(newPos)
if self.isHorizontal:
self.nodeP.move(newPos.x(), newPos.y() + 22)
self.nodeS.move(newPos.x() + 90, newPos.y() + 22)
self.valueText.move(newPos.x() + 30, newPos.y() + 40)
self.idLabel.move(newPos.x() + 45, newPos.y())
self.PropMenu.move(self.parent().frameGeometry().left() + newPos.x() + 20,
self.parent().frameGeometry().top() + newPos.y() + 100)
else:
self.nodeP.move(newPos.x() + 18, newPos.y())
self.nodeS.move(newPos.x() + 18, newPos.y() + 90)
self.valueText.move(newPos.x() + 40, newPos.y() + 45)
self.idLabel.move(newPos.x() + 40, newPos.y() + 25)
self.PropMenu.move(self.parent().frameGeometry().left() + newPos.x() + 100,
self.parent().frameGeometry().top() + newPos.y() + 20)
self.__mouseMovePos = globalPos
super(Inductor, self).mouseMoveEvent(event)
def mouseReleaseEvent(self, event):
if self.__mousePressPos is not None:
moved = event.globalPos() - self.__mousePressPos
if moved.manhattanLength() > 3:
event.ignore()
return
super(Inductor, self).mouseReleaseEvent(event)
def Rotate(self):
if(self.isHorizontal):
self.symbol = QPixmap()
self.symbol.load('ind2.png')
self.symbol = self.symbol.scaledToHeight(100)
self.resize(self.symbol.size())
self.setPixmap(self.symbol)
self.valueText.move(self.x() + 40, self.y() + 45)
self.idLabel.move(self.x() + 40, self.y() + 25)
self.valueText.setText(str(self.value) + ' H')
self.nodeP.move(self.x() + 18, self.y())
self.nodeS.move(self.x() + 18, self.y() + 90)
self.isHorizontal = False
else:
self.symbol = QPixmap()
self.symbol.load('ind.png')
self.symbol = self.symbol.scaledToWidth(100)
self.resize(self.symbol.size())
self.setPixmap(self.symbol)
self.valueText.move(self.x() + 30, self.y() + 40)
self.idLabel.move(self.x() + 45, self.y())
self.valueText.setText(str(self.value) + ' H')
self.nodeP.move(self.x(), self.y() + 22)
self.nodeS.move(self.x() + 90, self.y() + 22)
self.isHorizontal = True
def deleteMe(self):
self.hide()
self.nodeP.hide()
self.nodeS.hide()
self.idLabel.hide()
self.valueText.hide()
def show_detail(self):
self.setStyleSheet("background-color: yellow")
if self.isHorizontal:
self.direction.load('arrow_right.png')
self.direction = self.direction.scaledToWidth(100)
self.direction_label.resize(self.direction.size())
self.direction_label.setPixmap(self.direction)
self.direction_label.move(self.x(), self.y())
self.direction_label.show()
else:
self.direction.load('arrow_down.png')
self.direction = self.direction.scaledToHeight(100)
self.direction_label.resize(self.direction.size())
self.direction_label.setPixmap(self.direction)
self.direction_label.move(self.x(), self.y())
self.direction_label.show()
def hide_detail(self):
self.setStyleSheet("background-color: none")
self.direction_label.hide()
class LEDButton(QPushButton):
# normal
OFF = 0
BLUE = 1
GREEN = 2
RED = 3
YELLOW = 4
# extra
CALF = 5
def __init__(self, parent):
QPushButton.__init__(self, parent)
self.fPixmap = QPixmap()
self.fPixmapRect = QRectF(0, 0, 0, 0)
self.setCheckable(True)
self.setText("")
self.fLastColor = self.OFF
self.fPixmap.load(":/bitmaps/led_off.png")
self.setColor(self.BLUE)
def setColor(self, color):
self.fColor = color
self._loadPixmapNow()
# Fix calf off
if color == self.CALF:
self.fPixmap.load(":/bitmaps/led_calf_off.png")
size = self.fPixmap.width()
self.fPixmapRect = QRectF(0, 0, size, size)
self.setMinimumSize(size, size)
self.setMaximumSize(size, size)
def paintEvent(self, event):
painter = QPainter(self)
event.accept()
self._loadPixmapNow()
painter.drawPixmap(self.fPixmapRect, self.fPixmap, self.fPixmapRect)
def _loadPixmapNow(self):
if self.isChecked():
if self.fLastColor != self.fColor:
if self.fColor == self.OFF:
self.fPixmap.load(":/bitmaps/led_off.png")
elif self.fColor == self.BLUE:
self.fPixmap.load(":/bitmaps/led_blue.png")
elif self.fColor == self.GREEN:
self.fPixmap.load(":/bitmaps/led_green.png")
elif self.fColor == self.RED:
self.fPixmap.load(":/bitmaps/led_red.png")
elif self.fColor == self.YELLOW:
self.fPixmap.load(":/bitmaps/led_yellow.png")
elif self.fColor == self.CALF:
self.fPixmap.load(":/bitmaps/led_calf_on.png")
else:
return
self.fLastColor = self.fColor
elif self.fLastColor != self.OFF:
self.fPixmap.load(":/bitmaps/led_calf_off.png" if self.fColor == self.CALF else ":/bitmaps/led_off.png")
self.fLastColor = self.OFF
def png(nom):
"""Charge l'image <nom>.png depuis le repertoire 'images/'.
L'image doit être au format png, et son nom doit indiqué sans l'extension '.png'."""
pixmap = QPixmap()
pixmap.load(png_pth(nom), 'PNG')
return pixmap
