class Timer(QLabel):
def __init__(self, rock, time, coordinates, size, parent=None):
super(QLabel, self).__init__(parent)
self.parent = parent
self.rock = rock
self.time = time
self.timer = QBasicTimer()
self.setGeometry(coordinates[0], coordinates[1], size[0], size[1])
self.setText('Left Time for {}:{}'.format(str(self.rock), self.time))
def is_active(self):
return self.timer.isActive()
def stop(self):
if self.timer.isActive():
self.timer.stop()
def start(self):
self.timer.start(self.time, self)
def timerEvent(self, e):
if 0 >= self.time:
self.stop()
self.parent.game.end_game(self.rock)
self.time -= 1
self.setText('Left Time for {}:{}'.format(str(self.rock), self.time))
self.repaint()
class MyApp(QWidget):
def __init__(self):
super().__init__()
self.title = 'Ex5.7_QProgressBar'
self.posXY = (300, 40)
self.windowSize = (400, 300)
self.initUI()
def initUI(self):
self.pb = QProgressBar(self)
self.pb.setGeometry(30, 40, 200, 25)
self.btn = QPushButton('START', self)
self.btn.move(40, 80)
self.btn.clicked.connect(self.doAction)
self.timer = QBasicTimer()
self.step = 0
self.show_basic()
def show_basic(self):
self.setWindowTitle(self.title)
self.setGeometry(*self.posXY, *self.windowSize)
self.show()
def doAction(self):
if (self.step < 100 and self.timer.isActive()):
self.timer.stop()
self.btn.setText('START')
elif (self.step >= 100 and self.timer.isActive() != True):
self.step = 0
self.pb.setValue(self.step)
self.btn.setText('START')
else:
self.timer.start(100, self)
self.btn.setText('STOP')
def timerEvent(self, e):
if self.step >= 100:
self.timer.stop()
self.btn.setText('FINISHED!')
return
self.step += 1
self.pb.setValue(self.step)
class Example(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.progress_bar = QProgressBar(self)
self.progress_bar.setGeometry(30, 40, 200, 25)
self.btn = QPushButton('Start', self)
self.btn.move(30, 80)
self.btn.clicked.connect(self.doAction)
self.timer = QBasicTimer()
self.step = 0
self.setGeometry(300, 300, 280, 170)
self.setWindowTitle('QProgressBar')
self.show()
def timerEvent(self, QTimerEvent):
if self.step >= 100:
self.timer.stop()
self.btn.setText('Finished')
return
self.step += 1
self.progress_bar.setValue(self.step)
def doAction(self):
if self.timer.isActive():
self.timer.stop()
self.btn.setText('Start')
else:
self.timer.start(100, self)
self.btn.setText('Stop')
class ProgressBar(QtWidgets.QWidget):
def __init__(self, newobject, parent=None):
# super().__init__(parent)
self.newobject = newobject
self.pbar = QProgressBar(self)
self.pbar.setMinimumSize(QSize(280, 20))
self.pbar.setMaximumSize(QSize(280, 20))
self.timer = QBasicTimer()
self.timer.isActive()
def timerEvent(self, event):
if self.step >= self.newobject.total:
self.timer.stop()
return
self.pbar.setValue(self.newobject.size)
class Demo(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.setGeometry(300,300,300,200)
self.setWindowTitle("进度条组件")
self.bar = QProgressBar(self)
self.button = QPushButton('start', self)
#布局
layout = QVBoxLayout()
layout.addWidget(self.button)
layout.addWidget(self.bar)
self.setLayout(layout)
#添加信号
self.button.clicked.connect(self.doAction)
self.timer = QBasicTimer()
#创建计时器
self.step = 0
def timerEvent(self, e):
#设置停止时间
if self.step>=100:
self.timer.stop()
self.button.setText('Finished')
return
self.step=self.step+1
self.bar.setValue(self.step)
def doAction(self):
if self.timer.isActive():
self.timer.stop()
self.button.setText('start')
#开始计时
else:
self.timer.start(100,self)
self.button.setText('stop')
class Example(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.pbar = QProgressBar(self)
self.pbar.setGeometry(30, 40, 200, 25)
self.setStyleSheet("color: rgb(170, 0, 0);\n"
"background-color: rgb(170, 0, 0);")
#self.btn2 = QPushButton('presione X para continuar', self)
#self.btn2.setStyleSheet("background-color: rgb(255, 255, 255);")
#self.btn2.move(33, 115)
#self.btn2.lower()
self.btn = QPushButton('presione para cargar temperatura', self)
self.btn.setStyleSheet("background-color: rgb(255, 255, 255);")
self.btn.move(33, 80)
self.btn.clicked.connect(self.doAction)
self.timer = QBasicTimer()
self.step = 0
self.setGeometry(260, 260, 260, 160)
#self.setStyleSheet("color: rgb(170, 0, 0);\n"
#"background-color: rgb(170, 0, 0);")
self.setWindowTitle('Cargando')
self.move(385, 520)
self.setFixedSize(260, 160)
self.show()
def location_on_the_screen(self):
screen = QDesktopWidget().screenGeometry()
widget = self.geometry()
x = screen.width() - widget.width()
y = 2 * screen.height() - widget.height()
self.move(x, y)
def timerEvent(self, e):
if self.step >= 100:
self.timer.stop()
self.btn.setText('Presione X para continuar')
#self.btn2.raise_()
return
self.step = self.step + 1
self.pbar.setValue(self.step)
def doAction(self):
if self.timer.isActive():
self.timer.stop()
self.btn.setText('temperatura pausada')
else:
self.timer.start(100, self)
self.btn.setText('cargando...')
class DomeUi(QtWidgets.QMainWindow, Ui_MainWindow):
def __init__(self):
QtWidgets.QMainWindow.__init__(self)
Ui_MainWindow.__init__(self)
self.setupUi(self)
self.btn.clicked.connect(self.doAction)
self.timer = QBasicTimer()
self.step = 0
def timerEvent(self, e):
if self.step >= 100:
self.timer.stop()
self.btn.setText('Finished')
return
self.step = self.step + 1
self.pbar.setValue(self.step)
def doAction(self):
if self.timer.isActive():
self.timer.stop()
self.btn.setText('Start')
else:
self.timer.start(100, self)
self.btn.setText('Stop')
class learningBox(QWidget, learningbox_class):
def __init__(self, parent):
super(learningBox, self).__init__(parent)
self.setGeometry(430, 200, 421, 281)
self.setupUi(self)
self.timer = QBasicTimer()
self.i = 0
def timerEvent(self, e):
if self.i >= 100:
self.timer.stop()
return
self.i += 1
self.learningBar.setValue(self.i)
def finish_learning(self):
self.parent().btn_enable()
self.close()
def start(self):
if self.timer.isActive():
self.timer.stop()
else:
self.timer.start(100, self)
def cancel(self):
self.learningBar.setValue(0)
self.parent().btn_enable()
self.close()
class Example(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.pbar = QProgressBar(self)
self.pbar.setGeometry(30, 40, 200, 25)
self.btn = QPushButton('Start', self)
self.btn.move(40, 80)
self.btn.clicked.connect(self.doAction)
self.timer = QBasicTimer()
self.step = 0
self.setGeometry(300, 300, 280, 170)
self.setWindowTitle('ProgressBar')
self.show()
def timerEvent(self, e):
if self.step >= 100:
self.timer.stop()
self.btn.setText('Finished')
return
self.step = self.step + 1
self.pbar.setValue(self.step)
def doAction(self):
if self.timer.isActive():
self.timer.stop()
self.btn.setText('Start')
else:
self.timer.start(100, self)
self.btn.setText('Stop')
class TW(QWidget):
def __init__(self):
super().__init__()
self.progressbar = QProgressBar(self)
self.progressbar.setGeometry(30, 40 , 200 , 25)
self.btn = QPushButton("Start" , self)
self.btn.move(40, 80)
self.btn.clicked.connect(self.start)
self.timer = QBasicTimer()
self.step = 0
def start(self):
if self.timer.isActive():
self.timer.stop()
self.btn.setText("Start")
else:
self.timer.start(100 , self)
self.btn.setText("STOP")
def timerEvent(self, event ):
if self.step>=100:
self.timer.stop()
self.btn.setText("FINISHED")
self.progressbar.reset()
return
self.step += 1
self.progressbar.setValue(self.step)
class ProgressBarDemo(QWidget):
def __init__(self):
super().__init__()
self.progressBar = QProgressBar(self)
self.progressBar.setGeometry(30, 40, 200, 25)
self.btnStart = QPushButton('Start SIR', self)
self.btnStart.move(30, 90)
self.btnStart.clicked.connect(self.startProgress)
self.timer = QBasicTimer()
self.step = 0
def startProgress(self):
if self.timer.isActive():
self.timer.stop()
self.btnStart.setText('Start SIR')
else:
self.timer.start(100, self)
self.btnStart.setText('SIR will launch')
def timerEvent(self, event):
if self.step >= 100:
self.timer.stop()
self.btnStart.setText('Click here')
return
self.step += 1
self.progressBar.setValue(self.step)
class window(QWidget):
def __init__(self):
super().__init__()
self.init()
def init(self):
self.timer = QBasicTimer()
self.pbr = QProgressBar(self)
self.pbr.resize(200, 25)
self.step = 0
self.btn = QPushButton('start', self)
self.btn.clicked.connect(self.doaction)
self.btn.move(10, 10)
self.pbr.move(10, 50)
self.setGeometry(100, 100, 300, 300)
def timerEvent(self, e):
if self.step > 100:
self.timer.stop()
self.btn.setText('finshed')
return
else:
self.step += 1
self.pbr.setValue(self.step)
def doaction(self):
if self.timer.isActive():
self.timer.stop()
self.btn.setText('start')
else:
self.timer.start(100, self)
self.btn.setText('stop')
class TutorialWindow(QWidget):
def __init__(self):
super().__init__()
self.progressBar = QProgressBar(self)
self.progressBar.setGeometry(30, 40, 200, 25)
self.btnStart = QPushButton('Start', self)
self.btnStart.move(40, 80)
self.btnStart.clicked.connect(self.startProgress)
self.timer = QBasicTimer()
self.step = 0
def startProgress(self):
if self.timer.isActive():
self.timer.stop()
self.btnStart.setText('Start')
else:
self.timer.start(100, self)
self.btnStart.setText('Stop')
def timerEvent(self, event):
if self.step >= 100:
self.timer.stop()
self.btnStart.setText('Finished')
return
self.step = self.step + 1
self.progressBar.setValue(self.step)
class ProgressBar(QtWidgets.QWidget):
def __init__(self, parent=None):
QtWidgets.QWidget.__init__(self)
self.setGeometry(300, 300, 250, 150)
self.setWindowTitle('ProgressBar')
self.pbar = QProgressBar(self)
self.pbar.setGeometry(30, 40, 200, 25)
self.button = QPushButton('Start', self)
self.button.setFocusPolicy(Qt.NoFocus)
self.button.move(40, 80)
self.button.clicked.connect(self.onStart)
self.timer = QBasicTimer()
self.step = 0
def timerEvent(self, event):
if self.step >= 100:
self.timer.stop()
return
self.step = self.step + 1
self.pbar.setValue(self.step)
def onStart(self):
if self.timer.isActive():
self.timer.stop()
self.button.setText('Start')
else:
self.timer.start(100, self)
self.button.setText('Stop')
class Window3(QMainWindow):
def __init__(self):
super().__init__()
uic.loadUi('3 экран.ui', self)
self.setWindowIcon(QIcon('icon1.png'))
self.pbar = QProgressBar(self)
self.pbar.setGeometry(110, 220, 531, 30)
self.btn_save.clicked.connect(self.doAction)
self.timer = QBasicTimer()
self.step = 0
def timerEvent(self, e):
if self.step >= 100:
self.timer.stop()
self.btn_save.setText('Сохранено!')
self.label.setText('Готово! Спасибо что были с нами:3')
return
self.step = self.step + 10
self.pbar.setValue(self.step)
def doAction(self):
if self.timer.isActive():
self.timer.stop()
else:
self.timer.start(100, self)
self.btn_save.setText('Загрузка...')
class progressbar(QWidget):
def __init__(self, *args, **kwargs):
QWidget.__init__(self, *args, **kwargs)
self.setWindowTitle("Coder Programmer")
path = os.path.join(os.path.dirname(sys.modules[__name__].__file__),
'img.png')
self.setWindowIcon(QIcon(path))
self.progressBar = QProgressBar(self)
self.progressBar.setGeometry(30, 40, 300, 25)
self.btnStart = QPushButton('Start', self)
self.btnStart.move(145, 80)
self.btnStart.clicked.connect(self.startProgress)
self.timer = QBasicTimer()
self.step = 0
def startProgress(self):
if self.timer.isActive():
self.timer.stop()
self.btnStart.setText('start')
else:
self.timer.start(100, self)
self.btnStart.setText('Stop')
def timerEvent(self, event):
if self.step >= 100:
self.timer.stop()
self.btnStart.setText('Finished')
return
self.step = self.step + 1
self.progressBar.setValue(self.step)
class Example(QWidget):
def __init__(self): # __init__() - Конструктор класса в языке Python
super().__init__(
) # метод super() возвращает объект родителя из класса Example и мы вызыв его конструктор.
self.initUI()
def initUI(self):
self.pbar = QProgressBar(self) # это конструктор QProgressBar
self.pbar.setGeometry(
30, 40, 200, 25) # установка размеров и положения QProgressBar
self.btn = QPushButton('Start', self) # создание кнопки
self.btn.move(40, 80) # расположение кнопки
self.btn.clicked.connect(
self.doAction) # добавление действия на кнопку
self.timer = QBasicTimer() # создание объекта таймера
self.step = 0 # переменная
self.setGeometry(300, 300, 280, 170)
self.setWindowTitle('QProgressBar')
self.show()
def timerEvent(self, e):
if self.step >= 100:
self.timer.stop()
self.btn.setText('Finished')
return
self.step = self.step + 1
self.pbar.setValue(self.step)
def doAction(self):
if self.timer.isActive():
self.timer.stop()
self.btn.setText('Start')
else:
self.timer.start(100, self)
self.btn.setText('Stop')
class Example(QWidget):
def __init__(self):
super(Example, self).__init__()
self.initUI()
def initUI(self):
self.probar = QProgressBar(self)
self.probar.setGeometry(30, 40, 200, 25)
self.btn = QPushButton(self)
self.btn.move(40, 80)
self.btn.clicked.connect(self.doAction)
# to activate the progress bar we use the timer
self.timer = QBasicTimer()
self.step = 0
self.setGeometry(300, 300, 300, 300)
self.setWindowTitle('check box')
def doAction(self):
if self.timer.isActive():
self.timer.stop()
self.btn.setText('Start')
else:
self.timer.start(100, self)
self.btn.setText('Stop')
def timerEvent(self, a0: 'QTimerEvent'):
if self.step >= 100:
self.timer.stop()
self.btn.setText('Finished')
return
self.step += 1
self.probar.setValue(self.step)
class Example(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.pbar = QProgressBar(self)
# 新建(实例化)一个QProgressBar构造器
# self.pbar.setRange(a,b) 设置最大和最小值, 即取值范围
# setMaximum() setMinimum() 单独设置
self.pbar.setMaximum(4000)
# 不论最大值最小值设置为多少, 界面显示为 (Value- minimum)/(maximum - minimum) 加个 %
# 最大最小值主要用来调控当前最大值完成的程度为多少或者改变不同情况下进度条速度, 本例中就改变了进度条运行的速度
# self.pbar.setOrientation(Qt.Vertical) # 可用, 没问题 不过需要调改一下进度框的方向
self.pbar.setGeometry(30, 40, 200, 25)
# 设置该QProgressBar构造器的位置(前两个), 和大小(后两个)
self.btn = QPushButton('Start', self)
self.btn.move(40, 80)
self.btn.clicked.connect(self.doAction)
self.timer = QBasicTimer()
# QBasicTimers 是一个很快的、轻量级的定时器类，它主要被Qt内部使用。
# 所以，我们一般不建议在上层应用程序中直接使用这个类去做定时器工作。
# 在开发应用程序时，我们一般推荐使用QTimer类和QObject的成员函数startTimer来启动定时器
# QBasicTimer定时器是一种重复性定时器，即它在启动后会不断的向应用程序发送定时器事件，
# 直到你收到调用stop() 时才停止
self.step = 0
# 设置计步器
self.setGeometry(300, 300, 1000, 500)
self.setWindowTitle('QProgressBar')
self.show()
# 重构父类时间事件处理方法 捕捉时间事件,一旦有变化就执行此方法
def timerEvent(self, e):
if self.step >= 4000:
self.timer.stop()
self.btn.setText('Finished')
self.pbar.setValue(self.step)
return
self.step = self.step + 1
self.pbar.setValue(self.step)
# 默认情况是0~99
def doAction(self):
# 通过时间来控制, 每按一次button调用该函数, 判断定时器状态, 决定按后定时器状态
# self.timer.isActive()
# true:定时器处于工作状态中
# false: 定时器不处于工作状态
if self.timer.isActive():
self.timer.stop()
self.btn.setText('Start')
else:
self.timer.start(100, self)
# 调用start()方法, 启动定时器(按下)
# void QBasicTimer::start(int msec, QObject *object)
# msec: 定时时间间隔(毫秒 1000ms = 1s),(每过一个此时时间间隔, QBasicTimer便会发出一个时间事件), *object接受定时器事件的对象
self.btn.setText('Stop')
class AutoSaver(QObject):
"""
Class implementing the auto saver.
"""
AUTOSAVE_IN = 1000 * 3
MAXWAIT = 1000 * 15
def __init__(self, parent, save):
"""
Constructor
@param parent reference to the parent object (QObject)
@param save slot to be called to perform the save operation
@exception RuntimeError raised, if no parent is given
"""
super(AutoSaver, self).__init__(parent)
if parent is None:
raise RuntimeError("AutoSaver: parent must not be None.")
self.__save = save
self.__timer = QBasicTimer()
self.__firstChange = QTime()
def changeOccurred(self):
"""
Public slot handling a change.
"""
if self.__firstChange.isNull():
self.__firstChange.start()
if self.__firstChange.elapsed() > self.MAXWAIT:
self.saveIfNeccessary()
else:
self.__timer.start(self.AUTOSAVE_IN, self)
def timerEvent(self, evt):
"""
Protected method handling timer events.
@param evt reference to the timer event (QTimerEvent)
"""
if evt.timerId() == self.__timer.timerId():
self.saveIfNeccessary()
else:
super(AutoSaver, self).timerEvent(evt)
def saveIfNeccessary(self):
"""
Public method to activate the save operation.
"""
if not self.__timer.isActive():
return
self.__timer.stop()
self.__firstChange = QTime()
self.__save()
class AutoSaver(QObject):
"""
Class implementing the auto saver.
"""
AUTOSAVE_IN = 1000 * 3
MAXWAIT = 1000 * 15
def __init__(self, parent, save):
"""
Constructor
@param parent reference to the parent object (QObject)
@param save slot to be called to perform the save operation
@exception RuntimeError raised, if no parent is given
"""
super(AutoSaver, self).__init__(parent)
if parent is None:
raise RuntimeError("AutoSaver: parent must not be None.")
self.__save = save
self.__timer = QBasicTimer()
self.__firstChange = QTime()
def changeOccurred(self):
"""
Public slot handling a change.
"""
if self.__firstChange.isNull():
self.__firstChange.start()
if self.__firstChange.elapsed() > self.MAXWAIT:
self.saveIfNeccessary()
else:
self.__timer.start(self.AUTOSAVE_IN, self)
def timerEvent(self, evt):
"""
Protected method handling timer events.
@param evt reference to the timer event (QTimerEvent)
"""
if evt.timerId() == self.__timer.timerId():
self.saveIfNeccessary()
else:
super(AutoSaver, self).timerEvent(evt)
def saveIfNeccessary(self):
"""
Public method to activate the save operation.
"""
if not self.__timer.isActive():
return
self.__timer.stop()
self.__firstChange = QTime()
self.__save()
class Example(QWidget, first_form.Ui_Dialog):
def __init__(self):
super().__init__()
self.setupUi(self)
self.dsec.display("00")
self.sec.display("00")
self.min.display("0")
self.tmr = QBasicTimer()
# self.start_stop_btn.clicked.connect(self.inc_lcd)
self.start_stop_btn.clicked.connect(self.clock)
self.lap_reset_btn.clicked.connect(self.reset)
self.show()
# def inc_lcd(self):
# self.lcdDisplay.display(self.lcdDisplay.intValue() + 1)
def timerEvent(self, e):
self.dsec.display("{:02d}".format(self.dsec.intValue() + 1))
if self.dsec.intValue() >= 100:
self.dsec.display(0)
self.sec.display("{:02d}".format(self.sec.intValue() + 1))
if self.sec.intValue() >= 60:
self.sec.display(0)
self.min.display(self.min.intValue() + 1)
# self.inc_lcd()
def reset(self):
if not self.tmr.isActive():
self.tmr.stop()
self.dsec.display("00")
self.sec.display("00")
self.min.display("0")
else:
self.listWidget.addItem("{:3d} : {:02d} : {:02d}".format(self.min.intValue(), self.sec.intValue(), self.dsec.intValue()))
def clock(self):
print(self.tmr.isActive())
# self.tmr.start(1000, self)
if self.tmr.isActive():
self.tmr.stop()
print('stop')
else:
self.tmr.start(10, self)
class MyQt(QWidget): ##,
def __init__(self):
super(MyQt, self).__init__()
self.initUI()
#palette = QPalette()
#palette.setBrush(QPalette.Background, QBrush(QPixmap("gif.gif")))##2000.jpg
#self.setPalette(palette)
###-------------gif背景图片错误-------------##
movie = self.QMovie('gif.gif')
# self.labMovies.setMovie(movie)
# movie.start()
# movie.setCacheMode(self.QtGui.QMovie.CacheAll)
# movie.setSpeed(100)
self.movie_screen.setMovie(movie)
movie.start()
def initUI(self):
# 构建一个进度条
self.pbar = QProgressBar(self)
# 从左上角30-50的界面，显示一个200*25的界面
self.pbar.setGeometry(30, 50, 200, 25) # 设置进度条的位置
# 设置开始按钮
self.btn = QPushButton('开始', self)
self.btn.move(50, 90) # 按钮移动的位置
# 点击按钮
# 信号函数不能加括号
self.btn.clicked.connect(self.doAction)
# 构建一个计时器
self.timer = QBasicTimer()
# 计数
self.step = 0
self.setGeometry(300, 300, 280, 170)
self.setWindowTitle('我是进度条')
# self.setWindowIcon(QIcon('1.jpg'))
#self.show()
def doAction(self):
# 判断是否处于激活状态
if self.timer.isActive():
self.timer.stop()
self.btn.setText('开始')
else:
self.timer.start(100, self)
self.btn.setText('停止')
def timerEvent(self, *args, **kwargs):
if self.step >= 100:
# 停止进度条
self.timer.stop()
self.btn.setText('完成')
return
self.step += 1
# 把进度条每次充值的值赋给进图条
self.pbar.setValue(self.step)
class Windows(QWidget):
def __init__(self):
super().__init__()
self.initUI()
self.finished = False
def initUI(self):
self.setWindowTitle('进度条示例')
self.setWindowIcon(QIcon('./res/apaki.ico'))
self.setGeometry(400, 300, 400, 300)
self.pbar = QProgressBar(self)
self.btn = QPushButton("开始下载", self)
self.btn.clicked.connect(self.doAction)
self.timer = QBasicTimer()
self.step = 0
# -------------------------------------------------
cal = QCalendarWidget(self)
cal.clicked[QDate].connect(self.showData)
date = cal.selectedDate()
self.label = QLabel(self)
self.label.setText(date.toString())
grid = QGridLayout(self)
grid.addWidget(self.pbar, 0, 1)
grid.addWidget(self.btn, 0, 0)
grid.addWidget(self.label, 2, 0, 1, 2)
grid.addWidget(cal, 3, 0, 1, 2)
self.setLayout(grid)
def timerEvent(self, event):
if self.step >= 100:
self.timer.stop()
self.btn.setText('下载完成')
self.finished = True
return
self.step += 1
self.pbar.setValue(self.step)
def doAction(self):
if self.finished is not True:
if self.timer.isActive():
self.timer.stop()
self.btn.setText('继续')
else:
self.timer.start(100, self)
self.btn.setText('停止')
def showData(self, date):
self.label.setText(date.toString())
class myClass(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.setWindowTitle("进度条QProgressBar")
self.setGeometry(700, 300, 500, 400)
self.lab = QLabel("进度条", self)
self.lab.move(45, 50)
# 进度条控件
self.qgb = QProgressBar(self)
self.qgb.move(100, 50)
# 控件的大小
self.qgb.resize(300, 20)
# 配置一个值，控制进度条时钟,表示当前进度
self.pv = 0
# 声明一个时钟控件
self.timerl = QBasicTimer()
# 设置最大值和最小值
self.qgb.setMinimum(0)
self.qgb.setMaximum(100)
# 设置当前进度
self.qgb.setValue(self.pv)
# 载入按钮
self.btn = QPushButton("开始", self)
self.btn.move(100, 80)
self.btn.clicked.connect(self.myTimeChange) # 信号
self.show()
# 时钟控件切换的核心代码
def myTimeChange(self):
# 判断控件是否已经开启
if self.timerl.isActive():
self.timerl.stop()
self.btn.setText("开始")
else:
self.timerl.start(100, self) # 每隔一秒
self.btn.setText("停止")
# 重写时间控件的方法
def timerEvent(self, e):
if self.pv == 100:
self.timerl.stop()
self.btn.setText("完成")
self.btn.clicked.connect(self.close) # 点击完成后退出
print("完成")
else:
self.pv = self.pv + 1
self.qgb.setValue(self.pv)
print(self.pv)
class ProcessBar(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
"""初始化UI界面"""
# 创建进度条
self.pbar = QProgressBar(self)
self.pbar.setGeometry(30, 40, 200, 50)
# self.pbar.setFormat("%p")
# 创建按钮
self.btn = QPushButton('Start', self)
self.btn.move(40, 80)
self.btn.clicked.connect(self.doAction)
# 创建计时器
self.timer = QBasicTimer()
self.step = 0
# window settings
self.setGeometry(500, 500, 500, 360)
self.setWindowTitle("ProcessBar")
self.show()
# QObject 的事件处理函数
def timerEvent(self, e):
if self.step >= 100:
self.timer.stop()
self.btn.setText('Finished')
return
self.step = self.step + 1
self.pbar.setValue(self.step)
# print(self.step)
def doAction(self):
"""按钮动作"""
if self.timer.isActive():
self.timer.stop()
self.btn.setText('Start')
else:
# start() : 过期时间 & 事件接受者
self.timer.start(100, self)
self.btn.setText('Stop')
class Ui_FormProgressBar(QWidget):
def setupUi(self, Form):
Form.setObjectName("Form")
Form.resize(347, 271)
self.form = Form
self.progressBar = QtWidgets.QProgressBar(Form)
self.progressBar.setGeometry(QtCore.QRect(30, 70, 321, 23))
self.progressBar.setProperty("value", 0)
self.progressBar.setObjectName("progressBar")
self.pushButton = QtWidgets.QPushButton(Form)
self.pushButton.setGeometry(QtCore.QRect(190, 140, 93, 28))
self.pushButton.setObjectName("pushButton")
self.pushButton_2 = QtWidgets.QPushButton(Form)
self.pushButton_2.setGeometry(QtCore.QRect(50, 140, 93, 28))
self.pushButton_2.setObjectName("pushButton_2")
self.retranslateUi(Form)
QtCore.QMetaObject.connectSlotsByName(Form)
self.pushButton_2.setEnabled(False)
self.pushButton.clicked.connect(self.close)
self.pushButton_2.clicked.connect(self.close)
self.timer = QBasicTimer()
self.step = 0
def retranslateUi(self, Form):
_translate = QtCore.QCoreApplication.translate
Form.setWindowTitle(_translate("Form", "执行格式转换中"))
self.pushButton.setText(_translate("Form", "取消"))
self.pushButton_2.setText(_translate("Form", "完成"))
def timerEvent(self, e):
if self.step >= 100:
self.timer.stop()
self.pushButton_2.setEnabled(True)
return
self.step = self.step + 1
self.progressBar.setValue(self.step)
def doAction(self, value):
pass
if self.timer.isActive():
self.timer.stop()
else:
self.timer.start(10, self)
def exit(self):
sys.exit(0)
def close(self):
self.form.close()
class 진행바(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.bar1 = QProgressBar(self)
self.bar1.setOrientation(Qt.Vertical) #Horizontal
self.bar1.setGeometry(50, 50, 50, 300) # (x, y, width, height)
self.bar2 = QProgressBar(self)
self.bar2.setGeometry(150, 200, 250, 30) # (x, y, width, height)
self.bar2.setRange(0, 50)
self.label1 = QLabel(
f'이 바의 범위는 {self.bar2.minimum()} 부터 {self.bar2.maximum()} 입니다.',
self)
self.label1.move(170, 240)
self.label2 = QLabel('이 곳에 첫 번째 바의 값이 나옵니다.', self)
self.label2.move(50, 360)
self.btn = QPushButton('시작', self)
self.btn.move(50, 390)
self.btn.clicked.connect(self.runTimer)
self.value = 0
self.timer = QBasicTimer()
self.bar1.valueChanged.connect(self.changeValue)
self.setGeometry(300, 300, 500, 500)
self.setWindowTitle('QProgressBar')
self.show()
def runTimer(self):
if self.timer.isActive():
self.timer.stop()
self.btn.setText('시작')
else:
self.timer.start(self.bar1.maximum(), self)
self.btn.setText('중지')
def timerEvent(self, event):
if self.value >= self.bar1.maximum():
self.timer.stop()
self.btn.setText('완료')
return
self.value += 1
self.bar1.setValue(self.value)
def changeValue(self):
self.label2.setText(str(self.bar1.value()))
class Example(QMainWindow):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
exitAct = QAction(QIcon("exit.png"), "Exit", self)
exitAct.setShortcut("Ctrl+Q")
exitAct.setStatusTip("Exit application")
exitAct.triggered.connect(self.close)
self.statusBar()
menubar = self.menuBar()
fileMenu = menubar.addMenu("&File")
fileMenu.addAction(exitAct)
toolbar = self.addToolBar("Exit")
toolbar.addAction(exitAct)
self.pbar = QProgressBar(self)
self.pbar.setGeometry(50, 80, 200, 25)
self.btn = QPushButton('Start', self)
self.btn.move(50, 120)
self.btn.clicked.connect(self.doAction)
self.timer = QBasicTimer()
self.step = 0
self.setGeometry(300, 300, 350, 250)
self.setWindowTitle("Muestra tu progreso")
self.show()
def timerEvent(self, e):
if self.step >= 100:
self.timer.stop()
self.btn.setText('Finished')
return
self.step = self.step + 1
self.pbar.setValue(self.step)
def doAction(self):
if self.timer.isActive():
self.timer.stop()
self.btn.setText('Start')
else:
self.timer.start(100, self)
self.btn.setText('Stop')
class Example(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.pbar = QProgressBar(self)
self.pbar.setGeometry(30, 40, 200, 25)
self.btn = QPushButton('Start', self)
self.btn.move(40, 80)
self.btn.clicked.connect(self.doAction)
# タイマー
self.timer = QBasicTimer()
self.step = 0
self.setGeometry(300, 300, 280, 170)
self.setWindowTitle('QProgressBar')
self.show()
def timerEvent(self, e):
# カウントが100に達すると終了
if self.step >= 100:
self.timer.stop()
self.btn.setText('Finished')
return
# 呼ばれるたび1ずつ増やす
self.step = self.step + 1
self.pbar.setValue(self.step)
def doAction(self):
"""ボタンが押されると呼ばれる"""
# タイマーが実行中ならタイマーを停止する
if self.timer.isActive():
self.timer.stop()
self.btn.setText('Start')
# タイマーが停止中ならタイマーを実行する
else:
# (timeout[ms], イベントの受取先)
# timeoutで指定した時間間隔でシグナルが飛ぶ模様
self.timer.start(1000, self)
self.btn.setText('Stop')
class MyApp(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.pbar = QProgressBar(self)
self.pbar.setMaximum(9)
self.pbar.setGeometry(30, 40, 200, 25)
self.btn = QPushButton('Start', self)
self.btn.move(40, 80)
self.btn.clicked.connect(self.doAction)
self.result = QLineEdit(self)
self.result.resize(80, 25)
self.result.move(150, 80)
self.timer = QBasicTimer()
self.step = 0
self.setWindowTitle('QProgressBar')
self.setGeometry(300, 300, 300, 200)
self.show()
def timerEvent(self, e):
if self.step >= 9:
self.timer.stop()
self.btn.setText('Finished')
return
self.step = self.step + 1
#print(self.step)
self.Multi(self.step)
self.pbar.setValue(self.step)
def doAction(self):
if self.timer.isActive():
self.timer.stop()
self.btn.setText('Start')
else:
self.timer.start(1000, self)
self.btn.setText('Stop')
def Multi(self, step):
for i in range(1, 10, 1):
if step + 1 == 10:
break
#print('{n+1} * {i} + = {(step+1)*i}')
print('{} * {} = {}'.format((step + 1), i, (step + 1) * i))
self.result.setText(str((step + 1) * i))
class Example(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
self.pbar = QProgressBar(self)
self.pbar.setGeometry(30, 40, 200, 25)
self.progressLabel = QLabel('0%')
self.btn = QPushButton('Start', self)
self.btn.move(40, 80)
self.btn.clicked.connect(self.doAction)
self.timer = QBasicTimer()
self.step = 0
hbox = QHBoxLayout()
hbox.addWidget(self.pbar)
hbox.addWidget(self.progressLabel)
vbox = QVBoxLayout()
vbox.addLayout(hbox)
vbox.addWidget(self.btn)
self.setLayout(vbox)
self.setGeometry(300, 300, 280, 170)
self.setWindowTitle('QProgressBar')
self.show()
def timerEvent(self, e):
if self.step >= 100:
self.timer.stop()
self.btn.setText('Finished')
return
self.step = self.step + 1
self.pbar.setValue(self.step)
self.progressLabel.setText("{}%".format(self.step))
def doAction(self):
if self.timer.isActive():
self.timer.stop()
self.btn.setText('Start')
else:
self.timer.start(100, self)
self.btn.setText('Stop')
class App(QMainWindow):
def __init__(self):
super().__init__()
self.setWindowTitle('PyQt5 ProgressBar')
self.setWindowIcon(QIcon('images/python.png'))
##to add an external file for designing
self.setObjectName('main')
self.setStyleSheet(style.s)
self.setGeometry(10, 10, 400, 600)
##QProgressBar
self.pb = QtWidgets.QProgressBar(self)
self.pb.setGeometry(10, 10, 380, 30)
##QPushButton
self.btn1 = QtWidgets.QPushButton("Start", self)
self.btn1.move(10, 70)
self.btn1.clicked.connect(self.start)
self.btn2 = QtWidgets.QPushButton("Reset", self)
self.btn2.move(290, 70)
self.btn2.clicked.connect(self.reset)
##QBasicTimer
self.timer = QBasicTimer()
self.step = 0
##Functions
def start(self):
if self.timer.isActive():
self.timer.stop()
self.btn1.setText("Start")
else:
self.timer.start(100, self)
self.btn1.setText('Stop')
def timerEvent(self, event):
if self.step >= 100:
self.timer.stop()
self.btn1.setText('Start')
return
self.step += 1
self.pb.setValue(self.step)
def reset(self):
self.step = 0
self.pb.setValue(0)
class MyQt(QWidget):
def __init__(self):
super(MyQt, self).__init__()
self.initUI()
def initUI(self):
# 构建一个进度条
self.pbar = QProgressBar(self)
# 从左上角30-50的界面，显示一个200*25的界面
self.pbar.setGeometry(30, 50, 200, 25) # 设置进度条的位置
# 设置开始按钮
self.btn = QPushButton('开始', self)
self.btn.move(50, 90) # 按钮移动的位置
# 点击按钮
# 信号函数不能加括号
self.btn.clicked.connect(self.doAction)
# 构建一个计时器
self.timer = QBasicTimer()
# 计数
self.step = 0
self.setGeometry(300,300,280,170)
self.setWindowTitle('我是进度条')
self.setWindowIcon(QIcon('1.jpg'))
self.show()
def doAction(self):
# 判断是否处于激活状态
if self.timer.isActive():
self.timer.stop()
self.btn.setText('开始')
else:
self.timer.start(100,self)
self.btn.setText('停止')
def timerEvent(self, *args, **kwargs):
if self.step>=100:
# 停止进度条
self.timer.stop()
self.btn.setText('完成')
return
self.step+=1
# 把进度条每次充值的值赋给进图条
self.pbar.setValue(self.step)
class Example(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
# checkbox
cb = QCheckBox('show title', self)
cb.move(20, 20)
cb.toggle()
cb.stateChanged.connect(self.changeTitle)
# toggle button
self.col = QColor(0, 0, 0)
redb = QPushButton('red', self)
redb.setCheckable(True)
redb.move(20, 40)
redb.clicked[bool].connect(self.setColor)
greenb = QPushButton('green', self)
greenb.setCheckable(True)
greenb.move(20, 60)
greenb.clicked[bool].connect(self.setColor)
blueb = QPushButton('blue', self)
blueb.setCheckable(True)
blueb.move(20, 80)
blueb.clicked[bool].connect(self.setColor)
self.square = QFrame(self)
self.square.setGeometry(150, 20, 100, 100)
self.square.setStyleSheet('QWidget {background-color: %s}' %
self.col.name())
# slider
sld = QSlider(Qt.Horizontal, self)
sld.setFocusPolicy(Qt.NoFocus)
sld.setGeometry(20, 160, 100, 20)
sld.valueChanged[int].connect(self.changeValue)
self.label = QLabel('0', self)
self.label.setGeometry(140, 155, 80, 30)
# progressbar
self.pbar = QProgressBar(self)
self.pbar.setGeometry(20, 200, 200, 25)
self.btn = QPushButton('start', self)
self.btn.move(20, 230)
self.btn.clicked.connect(self.doAction)
self.timer = QBasicTimer()
self.step = 0
# calendar
cal = QCalendarWidget(self)
cal.setGridVisible(True)
cal.move(20, 300)
cal.clicked[QDate].connect(self.showDate)
self.lbl = QLabel(self)
date = cal.selectedDate()
self.lbl.setText(date.toString())
self.lbl.move(20, 280)
self.setGeometry(300, 300, 400, 550)
self.setWindowTitle('widgets')
self.show()
def showDate(self, date):
self.lbl.setText(date.toString())
def timerEvent(self, e):
if self.step >= 100:
self.timer.stop()
self.btn.setText('finished')
return
self.step = self.step + 1
self.pbar.setValue(self.step)
def doAction(self):
if self.timer.isActive():
self.timer.stop()
else:
self.timer.start(100, self)
self.btn.setText('stop')
def changeValue(self, value):
self.label.setText(str(value))
def setColor(self, pressed):
source = self.sender()
if pressed:
val = 255
else:
val = 0
if source.text() == 'red':
self.col.setRed(val)
elif source.text() == 'green':
self.col.setGreen(val)
else:
self.col.setBlue(val)
self.square.setStyleSheet('QFrame {background-color: %s}' %
self.col.name())
def changeTitle(self, state):
if state == Qt.Checked:
self.setWindowTitle('widgets')
else:
self.setWindowTitle('')
class OpenGLWidget(QOpenGLWidget):
def __init__(self, *args, **kwargs):
'''
Class representing OpenGL widget in the VisualizationWindow.
'''
super(OpenGLWidget, self).__init__(*args, **kwargs)
self._room = self.parent().room # assign room geometry to a variable
self.setGeometry(self.parent()._width * .25, 0, self.parent()._width, self.parent()._height) # window size/pos
self._timer = QBasicTimer() # create a timer
def initializeGL(self):
'''
A method to initialize all OpenGL features.
'''
glClearColor(.22, .22, .22, 1) # set background color to gray
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # make sure to clear everything at the beginning
glClearDepth(1) # set background depth to farthest
glEnable(GL_DEPTH_TEST) # enable depth testing for z-culling
glDepthFunc(GL_LEQUAL) # set the type of depth-test
glShadeModel(GL_SMOOTH) # enable smooth shading
glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST) # nice perspective corrections
glMatrixMode(GL_PROJECTION) # necessary for a nice perspective view
glLoadIdentity() # necessary for a nice perspective view
gluPerspective(45, (self.width() / self.height()), .1, 50.0) # configure perspective view
glMatrixMode(GL_MODELVIEW) # necessary for a nice model view
glLoadIdentity() # necessary for a nice model view
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE) # wireframe rendering method
gluLookAt( # camera position and looking point
-15, 8, -15,
-3, 0, 0,
0, 1, 0
)
def paintGL(self):
'''
A method to paint in OpenGL.
'''
glClearColor(.22, .22, .22, 1) # set background color to gray
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) # clear everything before rendering next frame
self._draw_grid() # drawing grid lines
self._draw_room() # drawing room geometry
if self._timer.isActive(): # if animation is initialized
self._draw_particles() # draw sound waves represented by particles
def timerEvent(self, QTimerEvent):
'''
An overridden method of what happens on each self._timer tick.
Warning! This method should only be used by self.initialize_animation()!!
:param QTimerEvent: should be ignored
'''
self.update() # calling self.update() in order to refresh the widget
def initialize_animation(self, source_pos=(0,0,0), source_spl=80, source_freq=1000, fps=60):
'''
A method to animate the ray tracing method in 4D.
:param source_pos: source position tuple
:param source_spl: source sound pressure level
:param source_freq: source sound frequency
'''
self._source_pos = source_pos
self._source_spl = source_spl
self._source_power = 10 ** (self._source_spl * .1)
self._source_freq = source_freq
self._calculate_particles_normals_positions_energies()
self._timer.start(1000 / fps, self)
def _draw_grid(self):
'''
A method to draw grid lines.
'''
glLineWidth(1) # width of a single grid line
glColor3f(.29, .29, .29, 1) # color of a single grid line (gray)
glBegin(GL_LINES) # tell OpenGL to draw lines
grid_lines = 10 # grid lines range (meaning its gird lines number / 4)
for i in range(-grid_lines, grid_lines + 1): # drawing grid lines
glVertex3f(-grid_lines, 0, i) # draw a horizontal line
glVertex3f(grid_lines, 0, i)
glVertex3f(i, 0, -grid_lines) # draw a vertical line
glVertex3f(i, 0, grid_lines)
glColor3f(.52, .07, .07, 1) # change line color to red
glVertex3f(-grid_lines, 0, 0) # draw red grid line
glVertex3f(grid_lines, 0, 0)
glColor3f(.07, .52, .07, 1) # change line color to green
glVertex3f(0, 0, -grid_lines) # draw green grid line
glVertex3f(0, 0, grid_lines)
glEnd() # tell OpenGL to stop drawing
def _draw_room(self):
'''
A method to draw room geometry.
'''
faces = self._room.faces # store room faces in a new variable
points = self._room.points # store room points in a new variable
glColor3f(.59, .59, .62, 1) # color of an edge (light gray)
for id in faces: # iterate through all faces
glBegin(GL_POLYGON) # tell OpenGL to draw a polygon
for point_id in faces[id][:-1]: # iterate through all points in a single face
glVertex3fv(points[point_id]) # draw a single point
glEnd() # tell OpenGL to stop drawing
def _draw_particles(self):
'''
A method to draw sound waves represented by particles.
'''
glBegin(GL_POINTS) # tell OpenGL to draw points
for index, particle in enumerate(self._particles_positions): # iterate through all particles
green = self._particles_energies[index] / self._source_spl # computing green color share in rgb palette
red = 1 - green # computing red color share in rgb palette
glColor3f(red, green, 0, 1) # color of a particle (initially green, then turning red)
glVertex3f(particle[0], particle[1], particle[2]) # draw each particle
self._recalculate_particles_normals() # recalculate particles normals
self._recalculate_particles_positions() # recalculate particles positions
glEnd() # stop drawing
def _calculate_particles_normals_positions_energies(self):
'''
A method to calculate normal vectors of all particles.
Warning! This method should be used only after initialize_animation()!
'''
particles_count = 15 # not the exact particles count, number of particles in a single ring
radius = .5 # radius of starting sphere
self._particles_normals = [] # list of all particles normals
self._particles_positions = [] # list of all particles current positions
self._particles_energies = [] # list of all particles energies that reduce each time a particle reflects
for i in range(0, particles_count): # iterate through each ring of particles
for j in range(0, particles_count): # iterate through each particle in the current ring
x = cos(2*pi * j / (particles_count-1)) * sin(pi * i / (particles_count-1)) # x position of particle
y = sin(-pi/2 + pi * i / (particles_count-1)) # y position of particle
z = sin(2*pi * j / (particles_count-1)) * sin(pi * i / (particles_count-1)) # z position of particle
self._particles_normals.append([x, y, z]) # add normal vector of each particle to the list
self._particles_positions.append([x*radius+self._source_pos[0], # add position of each particle
y*radius+self._source_pos[1], # to the list
z*radius+self._source_pos[2]])
self._particles_energies.append(self._source_spl) # each particle has energy equal to source spl
def _recalculate_particles_normals(self):
'''
A method to recalculate all particles normals in each frame.
Recalculates particles energies within each reflection and removes the particles with energy level below 60dB.
'''
self._particles_to_delete = [] # a list with indexes of particles with energy level below 60dB
for index, particle in enumerate(self._particles_positions): # iterate through all particles
if particle[0] <= self._room.boundaries['min_x'] or particle[0] >= self._room.boundaries['max_x']:
self._compute_new_particle_normal_and_reduce_energy('x', index) # react to particle reflection
elif particle[1] <= self._room.boundaries['min_y'] or particle[1] >= self._room.boundaries['max_y']:
self._compute_new_particle_normal_and_reduce_energy('y', index) # react to particle reflection
elif particle[2] <= self._room.boundaries['min_z'] or particle[2] >= self._room.boundaries['max_z']:
self._compute_new_particle_normal_and_reduce_energy('z', index) # react to particle reflection
for particle in sorted(self._particles_to_delete, reverse=True): # deleting particles with energy below 60dB
del self._particles_normals[particle]
del self._particles_positions[particle]
del self._particles_energies[particle]
def _recalculate_particles_positions(self):
'''
A method to recalculate all particles positions in each frame.
'''
for index, particle in enumerate(self._particles_positions): # iterate through all particles
normal = self._particles_normals[index] # assign a particle normal vector to a variable
self._particles_positions[index] = [ # override previous particle position with a new position
particle[0]+normal[0]*.1,
particle[1]+normal[1]*.1,
particle[2]+normal[2]*.1
]
def _compute_new_particle_normal_and_reduce_energy(self, axis, index):
'''
A method to compute new particle normals and reduce its energy level after reflection.
:param axis: either 'x', 'y' or 'z' based on which axis does the particle reflects
:param index: index of particle in all global lists
'''
normal = self._particles_normals[index] # assign a particle normal vector to a variable
if axis == 'x':
self._particles_normals[index] = ([-normal[0], normal[1], normal[2]]) # reflecting the particle
elif axis == 'y':
self._particles_normals[index] = ([normal[0], -normal[1], normal[2]]) # reflecting the particle
else:
self._particles_normals[index] = ([normal[0], normal[1], -normal[2]]) # reflecting the particle
# reducing particle energy
self._particles_energies[index] = 10 * log10(10 ** (self._particles_energies[index] * .1) * (1 - self._room.average_alpha[self._source_freq]))
if self._particles_energies[index] < self._source_spl - 60:
self._particles_to_delete.append(index) # queueing the particle to removal when its energy is below 60dB
class YaP(QWidget):
rate_url = 'poligon.info'
query = ''
query_list = []
res_label = ''
file_path_label = ''
rank = 0
file_taken = False
res_list = []
file_queries = []
fname = ''
r_count = 0
db_path = 'keywords.db'
xls_path = 'rating.xls'
yandex_limits = [
[0, 230, 0], [1, 276, 0], [2, 276, 0],
[3, 276, 0], [4, 276, 0], [5, 230, 0],
[6, 161, 0], [7, 92, 0], [8, 46, 0],
[9, 46, 0], [10, 46, 0], [11, 46, 0],
[12, 46, 0], [13, 46, 0], [14, 46, 0],
[15, 46, 2], [16, 46, 0], [17, 46, 0],
[18, 46, 0], [19, 46, 0], [20, 92, 0],
[21, 161, 0], [22, 230, 0], [23, 240, 0]
]
# req_date = str(datetime.now().strftime('%Y-%m-%d %H:%M:%S'))
req_date = str(datetime.now().strftime('%Y-%m-%d'))
query_url = 'https://yandex.ru/search/xml?user=webmaster-poligon\
&key=03.279908682:25776a70171503eb70359c5bd5b820dc&l10n=ru\
&groupby=groups-on-page%3D100&lr=2&query='
def __init__(self):
super().__init__()
self.initUI()
self.search_btn.clicked.connect(self.set_query)
self.search_btn.clicked.connect(self.start_search)
self.qfile_btn.clicked.connect(self.showOpenDialog)
self.sfile_btn.clicked.connect(self.db_xls)
def initUI(self):
grid = QGridLayout()
self.setLayout(grid)
lbl = QLabel('Выбран запрос: ')
grid.addWidget(lbl, 0, 0)
lbl1 = QLabel('Поиск по запросу: ')
grid.addWidget(lbl1, 3, 0)
self.label = QLabel(self)
grid.addWidget(self.label, 0, 1)
self.field = QLineEdit(self)
grid.addWidget(self.field, 3, 1)
self.field.textChanged[str].connect(self.push_query)
self.search_btn = QPushButton('Поиск')
grid.addWidget(self.search_btn, 3, 2)
self.qfile_btn = QPushButton('Файл запросов')
grid.addWidget(self.qfile_btn, 5, 0)
self.sfile_btn = QPushButton('Сохранить')
grid.addWidget(self.sfile_btn, 5, 2)
label_fake = QLabel()
grid.addWidget(label_fake, 4, 0)
label_fake1 = QLabel()
grid.addWidget(label_fake1, 2, 0)
self.label_done = QLabel()
grid.addWidget(self.label_done, 6, 1)
self.label_r = QLabel(self.res_label)
grid.addWidget(self.label_r, 4, 1)
self.label_fp = QLabel(self.file_path_label)
grid.addWidget(self.label_fp, 5, 1)
self.setGeometry(700, 350, 600, 200)
self.setWindowTitle('\"YaP\" - is a Yandex ratings for Poligon.info')
self.pbar = QProgressBar(self)
grid.addWidget(self.pbar, 7, 1)
self.timer = QBasicTimer()
self.step = 0
self.show()
def timerEvent(self, e):
if self.step >= 100:
self.timer.stop()
return
self.step = self.step + 1
self.pbar.setValue(self.step)
def sql_con(self, res_list):
conn = sqlite3.connect(self.db_path)
db = conn.cursor()
db.execute("select name from sqlite_master \
where type='table' and name='requests'")
if db.fetchone():
for res in self.res_list:
if len(self.file_queries) == 0:
k = (self.query.encode('utf-8').decode('cp1251'),
self.req_date,)
db.execute("select * from requests \
where keyword=? and date=?", k)
if db.fetchone():
db.execute("delete from requests \
where keyword=? and date=?", k)
else:
continue
else:
for q in self.file_queries:
k = (q, self.req_date,)
db.execute("select * from requests \
where keyword=? and date=?", k)
if db.fetchone():
db.execute("delete from requests \
where keyword=? and date=?", k)
else:
continue
db.executemany(
"insert into requests values (?, ?, ?)",
self.res_list)
else:
db.execute("create table requests (keyword, position, date)")
db.executemany(
"insert into requests values (?, ?, ?)",
self.res_list)
conn.commit()
db.close()
conn.close()
def db_xls(self):
conn = sqlite3.connect(self.db_path)
db = conn.cursor()
db.execute("select name from sqlite_master \
where type='table' and name='requests'")
wb = Workbook()
ws = wb.add_sheet('keywords')
plain = easyxf('')
if db.fetchone():
for r, row in enumerate(db.execute("select * from requests")):
for c, col in enumerate(row):
if (type(col) is int) != True:
ws.write(r, c, col.encode('cp1251')
.decode('utf-8'), plain)
else:
ws.write(r, c, col, plain)
print(col)
wb.save(self.xls_path)
db.close()
conn.close()
def showOpenDialog(self):
self.fname, _ = QFileDialog.getOpenFileName(self, 'Open file',
'C:\\Users\\gnato\\\
Desktop\\Igor\\progs\\\
python_progs\\YaP\\')
if len(self.fname) > 0:
book = xlrd.open_workbook(self.fname, 'rt', formatting_info=True)
sh = book.sheet_by_index(0)
else:
pass
for i in range(sh.nrows):
self.query_list.append(sh.cell_value(i, 0))
print('query_list is: ')
for l in self.query_list:
print(l.encode('utf-8').decode('cp1251'))
self.file_taken = True
fname_chars = []
for char in self.fname:
if (char == '/'):
fname_chars.append('\\')
else:
fname_chars.append(char)
win_path = ''.join(fname_chars)
self.label_fp.setText(win_path)
self.label_fp.adjustSize()
self.start_search(self.event)
def keyPressEvent(self, event):
if type(event) == QKeyEvent:
if event.key() == Qt.Key_Escape:
self.close()
elif event.key() == Qt.Key_Return:
self.set_query(self)
self.start_search(self)
def set_query(self, event):
self.query = self.field.text()
self.rank = 0
self.file_queries = []
def push_query(self, query):
self.label.setText(query)
self.label.adjustSize()
def start_search(self, event):
if self.timer.isActive():
self.timer.stop()
else:
self.timer.start(100, self)
self.label_done.setText(
'Запросы обработаны, результаты занесены в базу данных.\n\
Для сохранения в файл нажмите кнопку \"Сохранить\".')
if self.file_taken:
for j, item in enumerate(self.query_list):
self.query = self.query_list[j]
r = requests.get(self.query_url + self.query)
self.r_count += 1
# функция limit() может быть вызвана только один раз #
# во избежание неправильных показателей счётчика. #
limit_data = limit(self.r_count, self.db_path, self.req_date) #
# ########################################################### #
if (limit_data[0]):
result = r.text
result_list = result.split('<url>')
for i, item in enumerate(result_list):
if self.rate_url in item:
self.rank += i
break
self.res_list.append((
self.query.encode('utf-8').decode('cp1251'),
self.rank,
self.req_date,))
self.file_queries.append(
self.query.encode('utf-8').decode('cp1251'))
limit_resume = str(limit_data[1]) + ' - Winter is close!'
else:
limit_resume = str(limit_data[1]) +\
'Hour limit is here... Wait about ' +\
str(60 - int(datetime.now().strftime('%M'))) +\
' minuntes, please!'
self.sql_con(self.res_list)
print(limit_resume)
print(int(datetime.now().strftime('%Y-%m-%d')))
print(int(datetime.now().strftime('%Y-%m-%d'))-1)
else:
r = requests.get(self.query_url + self.query)
self.r_count += 1
result = r.text
result_list = result.split('<url>')
for i, item in enumerate(result_list):
if self.rate_url in item:
self.rank += i
break
if self.rank != 0:
self.res_label = ('По запросу \"' + self.query + '\" сайт poligon.info \
находится на ' + str(self.rank) + '-й позиции.\nДата запроса : '
+ self.req_date + '.')
self.label_r.setText(self.res_label)
self.label_r.adjustSize()
self.res_list.append((
self.query.encode('utf-8').decode('cp1251'),
self.rank,
self.req_date,))
self.sql_con(self.res_list)
else:
self.res_label = ('По запросу \"' + self.query + '\" сайт poligon.info \
находится ниже 100-й позиции.\nДата запроса : '
+ self.req_date + '.')
self.label_r.setText(self.res_label)
self.label_r.adjustSize()
self.res_list.append((
self.query.encode('utf-8').decode('cp1251'),
self.rank,
self.req_date,))
self.sql_con(self.res_list)
print('end')
print(self.res_list)
class Example(QWidget):
def __init__(self):
super(Example, self).__init__()
self.initUI()
def initUI(self):
# checkBox
cb = QCheckBox('show title', self)
cb.move(10, 10)
cb.toggle()
cb.stateChanged.connect(self.changeTitle)
# 颜色混合
self.col = QColor(0, 0, 0)
redb = QPushButton('Red', self)
redb.setCheckable(True)
redb.move(10, 30)
redb.clicked[bool].connect(self.setColor)
grnb = QPushButton('Green', self)
grnb.setCheckable(True)
grnb.move(10, 60)
grnb.clicked[bool].connect(self.setColor)
blueb = QPushButton('Blue', self)
blueb.setCheckable(True)
blueb.move(10, 90)
blueb.clicked[bool].connect(self.setColor)
self.square = QFrame(self)
self.square.setGeometry(150, 20, 50, 50)
self.square.setStyleSheet("QWidget { background-color: %s}" %
self.col.name())
# slider 滚动条
sld = QSlider(Qt.Horizontal, self)
sld.setFocusPolicy(Qt.NoFocus)
sld.setGeometry(10, 120, 100, 10)
sld.valueChanged[int].connect(self.changeValue)
self.label = QLabel(self)
self.label.setPixmap(QPixmap('1.png'))
self.label.setGeometry(150, 90, 80, 80)
# 进度条ProgressBar
self.pbar = QProgressBar(self)
self.pbar.setGeometry(10, 170, 200, 20)
self.btn = QPushButton('Start', self)
self.btn.move(10, 200)
self.btn.clicked.connect(self.doAction)
self.timer = QBasicTimer()
self.step = 0
# Calendar 日历
cal = QCalendarWidget(self)
cal.setGridVisible(True)
cal.move(10, 230)
cal.clicked[QDate].connect(self.showDate)
self.lbl = QLabel(self)
date = cal.selectedDate()
self.lbl.setText(date.toString())
self.lbl.move(80, 440)
self.setGeometry(300, 200, 300, 500)
self.setWindowTitle('Toggle')
self.show()
def changeTitle(self, state):
if state == Qt.Checked:
self.setWindowTitle('Toogle')
else:
self.setWindowTitle(' ')
def setColor(self, pressed):
source = self.sender()
if pressed:
val = 255
else:
val = 0
if source.text() == "Red":
self.col.setRed(val)
elif source.text() == "Green":
self.col.setGreen(val)
else:
self.col.setBlue(val)
self.square.setStyleSheet("QFrame {background-color: %s}" % self.col.name())
def changeValue(self, value):
if value == 0:
self.label.setPixmap(QPixmap('1.png'))
elif 0 < value <= 30:
self.label.setPixmap(QPixmap('2.png'))
elif 30 < value < 80:
self.label.setPixmap(QPixmap('3.png'))
else:
self.label.setPixmap(QPixmap('4.png'))
def timerEvent(self, *args, **kwargs):
if self.step >= 100:
self.timer.stop()
self.btn.setText('Finished')
return
self.step += 1
self.pbar.setValue(self.step)
def doAction(self):
if self.timer.isActive():
self.timer.stop()
self.btn.setText('Start')
else:
self.timer.start(100, self)
self.btn.setText('Stop')
def showDate(self, date):
self.lbl.setText(date.toString())
class Example(QWidget):
def __init__(self):
super().__init__()
self.initUI()
def initUI(self):
# checkbox
cb = QCheckBox('Show title', self)
cb.move(20, 160)
cb.toggle()
cb.stateChanged.connect(self.changeTitle)
# toggle button
self.col = QColor(0, 0, 0)
redb = QPushButton('Red', self)
redb.setCheckable(True)
redb.move(10, 10)
redb.clicked[bool].connect(self.setColor)
redb = QPushButton('Green', self)
redb.setCheckable(True)
redb.move(10, 60)
redb.clicked[bool].connect(self.setColor)
blueb = QPushButton('Blue', self)
blueb.setCheckable(True)
blueb.move(10, 110)
blueb.clicked[bool].connect(self.setColor)
self.square = QFrame(self)
self.square.setGeometry(150, 20, 100, 100)
self.square.setStyleSheet("QWidget { background-color: %s }" %
self.col.name())
# slider
sld = QSlider(Qt.Horizontal, self)
sld.setFocusPolicy(Qt.NoFocus)
sld.setGeometry(30, 210, 100, 30)
sld.valueChanged[int].connect(self.changeValue)
# pixmap
self.label = QLabel(self)
self.label.setPixmap(QPixmap('web.png'))
self.label.setGeometry(160, 210, 80, 30)
# process bar
self.pbar = QProgressBar(self)
self.pbar.setGeometry(30, 260, 200, 25)
self.btn = QPushButton('Start', self)
self.btn.move(40, 310)
self.btn.clicked.connect(self.doAction)
self.timer = QBasicTimer()
self.step = 0
# calendar
cal = QCalendarWidget(self)
cal.setGridVisible(True)
cal.move(300, 10)
cal.clicked[QDate].connect(self.showDate)
self.lbl = QLabel(self)
date = cal.selectedDate()
self.lbl.setText(date.toString())
self.lbl.move(300, 260)
# line edit
self.lbl2 = QLabel(self)
qle = QLineEdit(self)
qle.move(300, 310)
self.lbl2.move(480, 310)
qle.textChanged[str].connect(self.onChanged)
self.setGeometry(300, 300, 640, 480)
self.setWindowTitle('QCheckBox')
self.show()
def changeTitle(self, state):
if state == Qt.Checked:
self.setWindowTitle('QCheckBox')
else:
self.setWindowTitle('')
def setColor(self, pressed):
source = self.sender()
if pressed:
val = 255
else:
val = 0
if source.text() == "Red":
self.col.setRed(val)
elif source.text() == "Green":
self.col.setGreen(val)
else:
self.col.setBlue(val)
self.square.setStyleSheet("QFrame { background-color: %s }" %
self.col.name())
def changeValue(self, value):
if value == 0:
self.label.setPixmap(QPixmap('web.png'))
elif value > 0 and value <= 30:
self.label.setPixmap(QPixmap('web.png'))
elif value > 30 and value < 80:
self.label.setPixmap(QPixmap('web.png'))
else:
self.label.setPixmap(QPixmap('web.png'))
def timerEvent(self, e):
if self.step >= 100:
self.timer.stop()
self.btn.setText('Finished')
return
self.step = self.step + 1
self.pbar.setValue(self.step)
def doAction(self):
if self.timer.isActive():
self.timer.stop()
self.btn.setText('Start')
else:
self.timer.start(100, self)
self.btn.setText('Stop')
def showDate(self, date):
self.lbl.setText(date.toString())
def onChanged(self, text):
self.lbl2.setText(text)
self.lbl2.adjustSize()
class ScrollArea(QAbstractScrollArea):
"""A scroll area that supports kinetic scrolling and other features.
Instance attributes:
kineticscrolling (True): whether the wheel and pgup/pgdn keys etc use
kinetic scrolling
scrollupdatespersec (50): how many scroll updates to draw per second
(50 is recommended).
"""
kineticscrolling = True
scrollupdatespersec = 50
def __init__(self, parent=None, **kwds):
super().__init__(parent, **kwds)
self._scroller = None
self._scrollTimer = QBasicTimer()
def wheelEvent(self, ev):
if self.kineticscrolling:
self.kineticAddDelta(-ev.angleDelta())
else:
super().wheelEvent(ev)
def keyPressEvent(self, ev):
"""Kinetic cursor movements."""
hbar = self.horizontalScrollBar()
vbar = self.verticalScrollBar()
# add Home and End, even in non-kinetic mode
scroll = self.kineticScrollBy if self.kineticscrolling else self.scrollBy
if ev.key() == Qt.Key_Home:
scroll(QPoint(0, -vbar.value()))
elif ev.key() == Qt.Key_End:
scroll(QPoint(0, vbar.maximum() - vbar.value()))
elif self.kineticscrolling:
# make arrow keys and PgUp and PgDn kinetic
if ev.key() == Qt.Key_PageDown:
self.kineticAddDelta(QPoint(0, vbar.pageStep()))
elif ev.key() == Qt.Key_PageUp:
self.kineticAddDelta(QPoint(0, -vbar.pageStep()))
elif ev.key() == Qt.Key_Down:
self.kineticAddDelta(QPoint(0, vbar.singleStep()))
elif ev.key() == Qt.Key_Up:
self.kineticAddDelta(QPoint(0, -vbar.singleStep()))
elif ev.key() == Qt.Key_Left:
self.kineticAddDelta(QPoint(-hbar.singleStep(), 0))
elif ev.key() == Qt.Key_Right:
self.kineticAddDelta(QPoint(hbar.singleStep(), 0))
else:
super().keyPressEvent(ev)
else:
super().keyPressEvent(ev)
def scrollOffset(self):
"""Return the current scroll offset."""
x = self.horizontalScrollBar().value()
y = self.verticalScrollBar().value()
return QPoint(x, y)
def canScrollBy(self, diff):
"""Does not scroll, but return the actual distance the View would scroll.
diff is a QPoint instance.
"""
hbar = self.horizontalScrollBar()
vbar = self.verticalScrollBar()
x = min(max(0, hbar.value() + diff.x()), hbar.maximum())
y = min(max(0, vbar.value() + diff.y()), vbar.maximum())
return QPoint(x - hbar.value(), y - vbar.value())
def scrollForDragging(self, pos):
"""Slowly scroll the View if pos is close to the edge of the viewport.
Can be used while dragging things.
"""
viewport = self.viewport().rect()
dx = pos.x() - viewport.left() - 12
if dx >= 0:
dx = max(0, pos.x() - viewport.right() + 12)
dy = pos.y() - viewport.top() - 12
if dy >= 0:
dy = max(0, pos.y() - viewport.bottom() + 12)
self.steadyScroll(QPoint(dx*10, dy*10))
def scrollTo(self, pos):
"""Scroll the View to get pos (QPoint) in the top left corner (if possible).
Returns the actual distance moved.
"""
return self.scrollBy(pos - self.scrollOffset())
def scrollBy(self, diff):
"""Scroll the View diff pixels (QPoint) in x and y direction.
Returns the actual distance moved.
"""
hbar = self.horizontalScrollBar()
vbar = self.verticalScrollBar()
x = hbar.value()
hbar.setValue(hbar.value() + diff.x())
x = hbar.value() - x
y = vbar.value()
vbar.setValue(vbar.value() + diff.y())
y = vbar.value() - y
return QPoint(x, y)
def kineticScrollTo(self, pos):
"""Scroll the View to get pos (QPoint) in the top left corner (if possible).
Returns the actual distance the scroll area will move.
"""
return self.kineticScrollBy(pos - self.scrollOffset())
def kineticScrollBy(self, diff):
"""Scroll the View diff pixels (QPoint) in x and y direction.
Returns the actual distance the scroll area will move.
"""
ret = self.canScrollBy(diff)
if diff:
scroller = KineticScroller()
scroller.scrollBy(diff)
self.startScrolling(scroller)
return ret
def kineticAddDelta(self, diff):
"""Add diff (QPoint) to an existing kinetic scroll.
If no scroll is active, a new one is started (like kineticScrollBy).
"""
if isinstance(self._scroller, KineticScroller):
self._scroller.scrollBy(self._scroller.remainingDistance() + diff)
else:
self.kineticScrollBy(diff)
def steadyScroll(self, diff):
"""Start steadily scrolling diff (QPoint) pixels per second.
Stops automatically when the end is reached.
"""
if diff:
self.startScrolling(SteadyScroller(diff, self.scrollupdatespersec))
else:
self.stopScrolling()
def startScrolling(self, scroller):
"""Begin a scrolling operation using the specified scroller."""
self._scroller = scroller
if not self._scrollTimer.isActive():
self._scrollTimer.start(1000 / self.scrollupdatespersec, self)
def stopScrolling(self):
"""Stop scrolling."""
if self._scroller:
self._scrollTimer.stop()
self._scroller = None
def isScrolling(self):
"""Return True if a scrolling movement is active."""
return bool(self._scroller)
def timerEvent(self, ev):
"""Called by the _scrollTimer."""
diff = self._scroller.step()
# when scrolling slowly, it might be that no redraw is needed
if diff:
# change the scrollbars, but check how far they really moved.
if not self.scrollBy(diff) or self._scroller.finished():
self.stopScrolling()
