Python QProgressBar.setValue方法代码示例

# 需要导入模块: from PyQt5.QtWidgets import QProgressBar [as 别名]
# 或者: from PyQt5.QtWidgets.QProgressBar import setValue [as 别名]
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')

# 需要导入模块: from PyQt5.QtWidgets import QProgressBar [as 别名]
# 或者: from PyQt5.QtWidgets.QProgressBar import setValue [as 别名]
    def __init__(self, parent):
        QProgressBar.__init__(self, parent)

        self.fLeftClickDown = False
        self.fIsInteger     = False
        self.fIsReadOnly    = False

        self.fMinimum   = 0.0
        self.fMaximum   = 1.0
        self.fInitiated = False
        self.fRealValue = 0.0

        self.fLastPaintedValue   = None
        self.fCurrentPaintedText = ""

        self.fLabel = ""
        self.fName  = ""
        self.fPreLabel = " "
        self.fTextCall  = None
        self.fValueCall = None

        self.setFormat("(none)")

        # Fake internal value, 10'000 precision
        QProgressBar.setMinimum(self, 0)
        QProgressBar.setMaximum(self, 10000)
        QProgressBar.setValue(self, 0)

# 需要导入模块: from PyQt5.QtWidgets import QProgressBar [as 别名]
# 或者: from PyQt5.QtWidgets.QProgressBar import setValue [as 别名]
    def extract2csv(self, tabWidget, d):
        name = tabWidget.tabText(tabWidget.currentIndex())
        wid = tabWidget.currentWidget()
        start = wid.dateStart.text()
        end = wid.dateEnd.text()
        end = False if end == 'Now' else end

        fail = []
        progress = QProgressBar()

        progress.setRange(0, len(self.tabCsv))
        d.layout().addWidget(progress)
        progress.setValue(0)

        for i, device in enumerate(self.tabCsv[name]):
            try:
                dataFrame = self.db.dataBetween(device.tablename, ','.join(device.keys), start=start, end=end)
                dataFrame.to_csv('/tmp/PFS-%s-%s.csv' % (start[:-6], device.tablename))
                progress.setValue(i + 1)
            except Exception as e:
                print (e)
                fail.append(device.tablename)

        if fail:
            self.showInformation("Extraction error on %s" % ','.join(fail))
        else:
            self.showInformation("Extraction Completed")
        d.close()

# 需要导入模块: from PyQt5.QtWidgets import QProgressBar [as 别名]
# 或者: from PyQt5.QtWidgets.QProgressBar import setValue [as 别名]
class MainProcess(QFrame):
    def __init__(self, parent):
        super(MainProcess, self).__init__()
        self.parent = parent
        self.initUI()
        
    def initUI(self):
        self.pbar = QProgressBar(self)
        self.pbar.setGeometry(120, 40, 300, 25)
        
        self.doing = False
        self.btn = QPushButton(u'Старт', self)
        self.btn.move(20, 40)
        self.btn.clicked.connect(self.doAction)
        
        self.setAutoFillBackground(True)
        palette = self.palette()
        palette.setColor(self.backgroundRole(), QColor('white'))
        self.setPalette(palette)
        
        self.setFrameShape(_frameShape)
        self.setFrameShadow(_frameShadow)
        self.setLineWidth(_lineWidth)
        self.setMidLineWidth(_midLineWidth)
        
    def doAction(self):
        if not self.doing:
            self.btn.setText(u'Стоп')
            self.thread = MyThread()
            self.pbar.setValue(0)
            self.worker = Worker()
            self.worker.moveToThread(self.thread)
            self.doing = True
            #self.thread.started.connect(self.worker.process)#worker.process)
            self.worker.finished.connect(self.thread.quit)
            #self.worker.finished.connect(self.worker.deleteLater)
            #self.worker.finished.connect(self.update_button)
            self.thread.finished.connect(self.update_button)
            #self.worker.stoping.connect(self.thread.terminate)
            #self.btn.clicked.connect(self.worker.stop)
            QtCore.QMetaObject.invokeMethod(self.worker, 'process', Qt.QueuedConnection,
                                            QtCore.Q_ARG(object, self.parent),
                                            QtCore.Q_ARG(object, self.pbar))
                                            
            self.thread.start()
        else:
            #self.doing = False
            #self.btn.setText(u'Старт')
            self.thread.terminate()
            #self.pbar.setValue(0)
            pass

            
    def update_button(self):
        self.doing = False
        self.btn.setText(u'Старт')
        self.pbar.setValue(0)

# 需要导入模块: from PyQt5.QtWidgets import QProgressBar [as 别名]
# 或者: from PyQt5.QtWidgets.QProgressBar import setValue [as 别名]
class ErgebnissVorlage(QWidget):
    def __init__(self, parent=None):
        super(ErgebnissVorlage, self).__init__(parent)

        self.auswahlAlter = QComboBox()
        self.auswahlAlter.addItem("Bitte auswählen")
        for i in range(3, 18):
            self.auswahlAlter.addItem("{} Jahre / Jahrgang {}".format(i, date.today().year - i))

        self.auswahlGeschlecht = QComboBox()
        self.auswahlGeschlecht.addItem("Bitte auswählen")
        self.auswahlGeschlecht.addItem("Männlich")
        self.auswahlGeschlecht.addItem("Weiblich")

        self.printerProgress = QProgressBar()
        self.printerProgress.hide()

        self.mainLayout = QFormLayout()
        self.mainLayout.addRow(QLabel("Alter:"),self.auswahlAlter)
        self.mainLayout.addRow(QLabel("Geschlecht:"),self.auswahlGeschlecht)
        self.mainLayout.addRow(self.printerProgress)

        self._drucken = QPushButton("Drucken")
        self._drucken.clicked.connect(self.drucken)

        self.mainLayout.addRow(self._drucken)

        self.setLayout(self.mainLayout)

    def queryUsers(self,Alter:int, Geschlecht:bool)->list:
        return QueryTool().fetchAllByWhere("LG_NGD",WieAlt=Alter,Geschlecht=Geschlecht)

    def drucken(self):
        self.printerProgress.show()

        if (self.auswahlAlter.currentIndex() is 0) and (self.auswahlGeschlecht.currentIndex() is 0):
            Alter = range(3,18)
            Geschlecht = range(0,2)
        else:
            Alter = self.auswahlAlter.currentIndex()+2
            Alter = range(Alter,Alter+1)

            Geschlecht = self.auswahlGeschlecht.currentIndex()-1
            Geschlecht = range(Geschlecht,Geschlecht+1)

        self.printerProgress.setMaximum(len(Alter)*len(Geschlecht)*10)
        self.printerProgress.setValue(0)

        prog = 0

        for a in Alter:
            for g in Geschlecht:
                for d in range(10):
                    ErgebnissVorlagenDrucker(a,g,d)
                    self.printerProgress.setValue(prog)
                    prog +=1
        self.printerProgress.hide()

# 需要导入模块: from PyQt5.QtWidgets import QProgressBar [as 别名]
# 或者: from PyQt5.QtWidgets.QProgressBar import setValue [as 别名]
class LabeledProgressBar(QWidget):

    def __init__(self,
                 label_text="Progress:",
                 label_font_size=10,
                 bar_width=100,
                 use_bar=None,
                 label_on_left=True,
                 show_bar_text=False,
                 *args, **kwargs):

        super().__init__(*args, **kwargs)

        if use_bar:
            self.bar = use_bar
        else:
            self.bar = QProgressBar(self)
        self.bar.reset()
        self.bar.setFixedWidth(bar_width)
        self.bar.setTextVisible(show_bar_text)

        self.label = QLabel(label_text, self)
        self.label.setAlignment(Qt.AlignRight)

        self.setStyleSheet("QLabel {font-size: %dpt}" % label_font_size)

        layout = QHBoxLayout()
        layout.setContentsMargins(0,0,0,0)

        if label_on_left:
            layout.addWidget(self.label)
            layout.addWidget(self.bar)
        else:
            layout.addWidget(self.bar)
            layout.addWidget(self.label)

        self.setLayout(layout)

    @pyqtProperty(int)
    def value(self):
        return self.bar.value()

    @value.setter
    def value(self, val):
        self.bar.setValue(val)

    def setValue(self, progress_value):
        self.bar.setValue(progress_value)

    @pyqtProperty(str)
    def label_text(self):
        return self.label.text()

    @label_text.setter
    def label_text(self, text):
        self.label.setText(text)

# 需要导入模块: from PyQt5.QtWidgets import QProgressBar [as 别名]
# 或者: from PyQt5.QtWidgets.QProgressBar import setValue [as 别名]
    def setValue(self, value):
        self.fRealValue = value
        div = float(self.fMaximum - self.fMinimum)

        if div == 0.0:
            print("Parameter '%s' division by 0 prevented (value:%f, min:%f, max:%f)" % (self.fName, value, self.fMaximum, self.fMinimum))
            vper = 1.0
        else:
            vper = float(value - self.fMinimum) / div

        QProgressBar.setValue(self, int(vper * 10000))

# 需要导入模块: from PyQt5.QtWidgets import QProgressBar [as 别名]
# 或者: from PyQt5.QtWidgets.QProgressBar import setValue [as 别名]
class ProgressMessageBar(QObject):
    
    def __init__(self, iface, message, minValue=10, delta=40, connector=None):
        super(ProgressMessageBar, self).__init__()
        self.iface = iface
        self.minValue = minValue
        self.delta = delta
        self.progress = None
        self.msgBar = None
        self.aborted = False
        if self.iface is not None:
            self.msgBar = self.iface.messageBar().createMessage('DIVI',message)
            self.progress = QProgressBar()
            self.button = QPushButton(self.tr('Abort'))
            self.msgBar.layout().addWidget(self.progress)
            self.msgBar.layout().addWidget(self.button)
            self.iface.messageBar().pushWidget(self.msgBar, Qgis.Info)
            if connector is not None:
                self.button.clicked.connect(connector.abort)
                self.button.clicked.connect(self.abort)
    
    def setProgress(self, value):
        try:
            progress = self.minValue+int(self.delta*value)
            if self.iface is not None:
                self.iface.mainWindow().statusBar().showMessage( self.tr("Loading layer {} %").format(progress) )
                self.progress.setValue(progress)
        except RuntimeError:
            pass
    
    def setValue(self, value):
        try:
            if self.iface is not None:
                self.iface.mainWindow().statusBar().showMessage( self.tr("Loading layer {} %").format(value) )
                self.progress.setValue(value)
        except RuntimeError:
            pass
    
    def setBoundries(self, minValue=None, delta=None):
        if minValue is not None:
            self.minValue = minValue
        if delta is not None:
            self.delta = delta
    
    def abort(self):
        self.aborted = True
    
    def close(self):
        if self.iface is not None:
            self.iface.messageBar().popWidget(self.msgBar)
            self.progress = None
            self.msgBar = None

# 需要导入模块: from PyQt5.QtWidgets import QProgressBar [as 别名]
# 或者: from PyQt5.QtWidgets.QProgressBar import setValue [as 别名]
class PowerIndicator():
    parent = None
    progressbar = None
    text = None

    maxVoltPerCell = 0
    minVoltPerCell = 0

    fullStyle = "QProgressBar::chunk { background-color: #00EE00; }"
    halfStyle = "QProgressBar::chunk { background-color: #FFCC00; }"
    emptyStyle = "QProgressBar::chunk { background-color: #FF5050; }"

    def __init__(self, parent, minVoltPerCell = 3.2, maxVoltPerCell = 4.2):
        self.minVoltPerCell = 3.2
        self.maxVoltPerCell = 4.2

        self.parent = parent
        self.text = QLabel('', parent)

        self.progressbar = QProgressBar(parent)
        self.progressbar.setMaximumWidth(100)
        self.progressbar.setMaximumHeight(10)
        self.progressbar.setMaximum(100)
        self.progressbar.setMinimum(0)
        self.progressbar.setTextVisible(False)

        parent.statusBar.addPermanentWidget(self.progressbar)
        parent.statusBar.addPermanentWidget(self.text)

    def updateProgressBar(self, voltage):
        pct = ((voltage - self.minVoltPerCell) / (self.maxVoltPerCell-self.minVoltPerCell))*100
        self.progressbar.setValue(pct)

        if pct <= 20:
            self.progressbar.setStyleSheet(self.emptyStyle)
        elif pct <= 50:
            self.progressbar.setStyleSheet(self.halfStyle)
        else:
            self.progressbar.setStyleSheet(self.fullStyle)

    def newMessage(self, message, data):
        if message == 'POW':
            data = data.split()

            if len(data) < 2:
                return

            volts = unpack('!f', bytes.fromhex(data[0]))[0]
            amps = unpack('!f', bytes.fromhex(data[1]))[0]

            self.text.setText("%.2f V/cell, %.3f A" % (volts/4, amps))
            self.updateProgressBar(volts/4)

# 需要导入模块: from PyQt5.QtWidgets import QProgressBar [as 别名]
# 或者: from PyQt5.QtWidgets.QProgressBar import setValue [as 别名]
 def start_download(self, filepath, path):
     #thread = QThread(self)
     pbar = QProgressBar(self.ui.tab_downloads)
     pbar.setMinimum(0)
     pbar.setMaximum(100)
     pbar.setValue(0)
     self.ui.formLayout.addRow(os.path.basename(path), pbar)
     pbar.show()
     dw = Downloader(str(filepath), str(path), pbar)
     dw.finished.connect(self.finished_download)
     dw.progresschanged.connect(self.show_download_progress)
     dw.started.connect(self.started_download)
     Thread(target=dw.download).start()

# 需要导入模块: from PyQt5.QtWidgets import QProgressBar [as 别名]
# 或者: from PyQt5.QtWidgets.QProgressBar import setValue [as 别名]
class qualityWidget(QWidget):
    def __init__(self,winParent, laser1, laser2, laser3):    
        super(qualityWidget, self).__init__()
        self.winParent=winParent
        self.laser1 = laser1
        self.laser2 = laser2
        self.laser3 = laser3
        self.numCrash = 0
        self.MAX_CRASH = 1000

        vLayout = QVBoxLayout()
        crashLabel = QLabel("Crash:")
        self.bar = QProgressBar()
        self.bar.setValue(self.numCrash)
        st = "QProgressBar::chunk {background-color: #ff0000;}\n QProgressBar {border: 1px solid grey;border-radius: 2px;text-align: center;background: #eeeeee;}"
        self.bar.setStyleSheet(st)
        self.bar.setTextVisible(False)
        vLayout.addWidget(crashLabel, 0)
        vLayout.addWidget(self.bar, 0)

        vSpacer = QSpacerItem(30, 80, QSizePolicy.Ignored, QSizePolicy.Ignored)
        vLayout.addItem(vSpacer)

        self.setLayout(vLayout)
        
        
    def get_laser_distance(self, laser):
        DIST = 15
        maxAngle = 180
        crash = False
        for i in range(0, maxAngle+1):
            # Distance in millimeters, we change to cm
            laserI = float(laser.distanceData[i])/float(10)
            if i != 0 and i != 180:
                if laserI <= DIST:
                    crash = True
        return crash
                    

    def updateG(self):
        laser_data_Front = self.laser1.getLaserData()
        laser_data_Rear = self.laser2.getLaserData()
        laser_data_Right = self.laser3.getLaserData()
        crashFront = self.get_laser_distance(laser_data_Front)
        crashRear = self.get_laser_distance(laser_data_Rear)
        crashRight = self.get_laser_distance(laser_data_Right)
        if crashFront or crashRear or crashRight:
            self.numCrash = self.numCrash + 1
        percentajeCrash = self.numCrash * 100/self.MAX_CRASH
        self.bar.setValue(self.numCrash)
        self.update()

# 需要导入模块: from PyQt5.QtWidgets import QProgressBar [as 别名]
# 或者: from PyQt5.QtWidgets.QProgressBar import setValue [as 别名]
class Example(QWidget):
    def __init__(self):
        super().__init__()
        self.resize(640, 320)
        self.setWindowTitle('PyQt-5 WebEngine')

        page = "https://www.google.com"

        self.url = QLineEdit(page)
        self.url.setPlaceholderText(page)

        self.go = QPushButton("Ir")
        self.go.clicked.connect(self.btnIrClicked)

        self.nav_bar = QHBoxLayout()
        self.nav_bar.addWidget(self.url)
        self.nav_bar.addWidget(self.go)

        self.progress = QProgressBar()
        self.progress.setValue(0)

        html = """
        <!DOCTYPE HTML>
            <html>
                <head>
                    <title>Example Local HTML</title>
                </head>
                <body>
                    <p>Este es un archivo <code>HTML</code> local.</p>
                    <p>Si deseas acceder página indica su <code>URL</code> y presiona <b>Ir</b></p>
                </body>
            </html>
        """

        self.web_view = QWebEngineView()
        self.web_view.loadProgress.connect(self.webLoading)
        self.web_view.setHtml(html)

        root = QVBoxLayout()
        root.addLayout(self.nav_bar)
        root.addWidget(self.web_view)
        root.addWidget(self.progress)

        self.setLayout(root)

    def btnIrClicked(self, event):
        url = QUrl(self.url.text())
        self.web_view.page().load(url)

    def webLoading(self, event):
        self.progress.setValue(event)

# 需要导入模块: from PyQt5.QtWidgets import QProgressBar [as 别名]
# 或者: from PyQt5.QtWidgets.QProgressBar import setValue [as 别名]
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')

# 需要导入模块: from PyQt5.QtWidgets import QProgressBar [as 别名]
# 或者: from PyQt5.QtWidgets.QProgressBar import setValue [as 别名]
class ShipHp(QWidget):
    def __init__(self, parent):
        super(ShipHp, self).__init__(parent)
        self.vbox = QVBoxLayout()
        self.vbox.setSpacing(0)
        self.vbox.setContentsMargins(0,3,0,3)

        self.setLayout(self.vbox)
        self.hp = QLabel(self)
        #self.hp.setMinimumSize(QSize(0, 50))
        self.vbox.addWidget(self.hp)

        self.hp_bar = QProgressBar(self)
        self.vbox.addWidget(self.hp_bar)
        sizePolicy = QSizePolicy(QSizePolicy.Fixed, QSizePolicy.Fixed)
        self.hp_bar.setSizePolicy(sizePolicy)
        self.hp_bar.setMinimumSize(QSize(100, 10))
        self.hp_bar.setMaximumSize(QSize(100, 10))

        self.vbox.addItem(QSpacerItem(40, 20,
                                      QSizePolicy.Minimum,
                                      QSizePolicy.Expanding))

    def set_hp(self, hp, maxhp):
        self.hp.setText(HP_FORMAT.format(hp, maxhp))
        self.hp_bar.setValue(hp*100/maxhp)
        self.hp_bar.setFormat('')
        rate = float(hp) / float(maxhp)
        if rate <= 0.25:
            self.setProperty('damage', 'serious')
        elif rate <= 0.50:
            self.setProperty('damage', 'middle')
        elif rate <= 0.75:
            self.setProperty('damage', 'slight')
        else:
            self.setProperty('damage', 'none')

        self.style().unpolish(self.hp_bar)
        self.style().polish(self.hp_bar)
        self.update()

    # for apply stylesheet
    def paintEvent(self, pe):
        opt = QStyleOption()
        opt.initFrom(self)
        p = QPainter(self)
        s = self.style()
        s.drawPrimitive(QStyle.PE_Widget, opt, p, self)

# 需要导入模块: from PyQt5.QtWidgets import QProgressBar [as 别名]
# 或者: from PyQt5.QtWidgets.QProgressBar import setValue [as 别名]
class setupWidget(QWidget):

	def __init__(self,parent_):
		super(setupWidget,self).__init__(parent_)
		self.parent_=parent_
		self.initUI()

	def initUI(self):
		self.pbar = QProgressBar(self)
		self.pbar.setObjectName('pbar')
		self.pbar.setTextVisible(True)
		self.pbar.setFormat('Configuring...')

		self.timer = QBasicTimer()
		self.step = 0

		pixmap=QPixmap(':/Assets/moodly.gif')
		lbl=QLabel(self)
		lbl.setPixmap(pixmap)

		hbox1=QHBoxLayout()
		hbox1.addStretch(1)
		hbox1.addWidget(lbl)
		hbox1.addStretch(1)

		hbox2=QHBoxLayout()
		hbox2.addStretch(1)
		hbox2.addWidget(self.pbar)
		hbox2.addStretch(1)

		vbox=QVBoxLayout()
		vbox.addStretch(8)
		vbox.addLayout(hbox1)
		vbox.addStretch(1)
		vbox.addLayout(hbox2)
		vbox.addStretch(8)

		self.setLayout(vbox)
		self.callTimer()

	def timerEvent(self,e):
		if self.step>=100:
			self.step=0
		self.step=self.step+1
		self.pbar.setValue(self.step)

	def callTimer(self):
		 self.timer.start(100, self)