Develop Reference

Pyside6 GUI crashes when updating GUI after thread

So basically the title, after threading I try to update the GUI, but it stops responding and closes. I am using qt designer so the GUI itself is in another file. The first code block is where I make the GUI interactive. The second is what will be run in the thread. I really appreciate any help you can provide.
Main thread
class interact(QtWidgets.QMainWindow, Ui_MainWindow):
def __init__(self, *args, **kwargs):
super(interact, self).__init__( *args, **kwargs)
self.setupUi(self)
self.scaleX = 800
self.scaleY = 800
self.index = 0
self.newIndex = 0
self.translatedFiles = []
self.files = []
self.isClicked = False
self.upload.clicked.connect(self.upload1)#connecting button to self.upload1
self.upload.clicked.connect(self.change1)
self.rightArrow.clicked.connect(self.moveRight) #button
self.leftArrow.clicked.connect(self.moveLeft) #button
self.translate.clicked.connect(self.translate1) #button
self.translate.clicked.connect(self.change)
def upload1(self):
filenames, _ = QFileDialog.getOpenFileNames(
None,
"QFileDialog.getOpenFileNames()",
"",
"Image files (*.jpg *.png)"
)
for file in filenames:
self.files.append(file)
self.showImage()
def moveRight(self):
if self.isClicked == True:
if self.newIndex >= len(self.translatedFiles)-1:
self.newIndex = len(self.translatedFiles)-1
else:
self.newIndex += 1
else:
if self.index >= len(self.files)-1:
self.index = len(self.files)-1
else:
self.index += 1
self.showImage()
def moveLeft(self):
if self.isClicked == True:
if self.newIndex <= 0:
self.newIndex = 0
else:
self.newIndex -= 1
else:
if self.index <= 0:
self.index = 0
else:
self.index -= 1
self.showImage()
def showImage(self):
#actual = QImage(self.files[self.index])
if self.isClicked == True:
im = self.translatedFiles[self.newIndex]
im = im.convert("RGB")
data = im.tobytes("raw","RGB")
qim = QImage(data, im.size[0], im.size[1], QImage.Format_RGB888)
pix = QPixmap(qim)
self.Image.setPixmap(pix)
print("change")
else:
pix = QPixmap(self.files[self.index])
self.Image.setPixmap(pix)
print(self.files[self.index])
print("KC")
def afterThread(self, s):
myarray = np.array(s)
img = im.fromarray(myarray)
self.translatedFiles.append(img)
print("THREAD COMPLETE!")
def change(self):
self.isClicked = True
def change1(self):
self.isClicked = False
def translate1(self):
self.thread = QThread()
self.worker = Translate(self.files[self.index])
self.worker.moveToThread(self.thread)
self.thread.started.connect(self.worker.run)
self.worker.finished.connect(self.afterThread)
self.worker.finished.connect(self.thread.quit)
self.worker.finished.connect(self.worker.deleteLater)
self.thread.finished.connect(self.thread.deleteLater)
self.thread.finished.connect(self.showImage)
self.thread.start()
if __name__ == "__main__":
import sys
app =QtWidgets.QApplication(sys.argv)
w = interact()
w.show()
sys.exit(app.exec())
Thread:
class Translate(QObject):
finished = Signal(list)
def __init__(self, img):
super(Translate, self).__init__()
self.img1 = cv2.imread(img)
self.image = cv2.cvtColor(self.img1, cv2.COLOR_BGR2RGB)
self.mocr = MangaOcr()
# self.run()
def chronos(func):
def get_time(*args, **kawrgs):
start = time.time()
x = func(*args, **kawrgs)
end = time.time()
print("{} took {} seconds".format(func, (end-start)))
return x
return get_time
#chronos
def get_text(self, image):
reader = easyocr.Reader(['ja'], gpu=False)
result = reader.readtext(image, paragraph=True)
myDict = {}
for (bbox, text) in result:
(tl, tr, br, bl) = bbox
tl = (int(tl[0]), int(tl[1]))
tr = (int(tr[0]), int(tr[1]))
br = (int(br[0]), int(br[1]))
bl = (int(bl[0]), int(bl[1]))
myDict[str(bl)] = ([tl , br ])
return myDict
#chronos
def get_japanese(self, diction):
newList = {}
et = {}
ts = {}
directory = os.getcwd()+'\MangaTranslation\cropText'
for x in diction:
cropped_image = self.image[diction[x][0][1]:diction[x][1][1], diction[x][0][0]:diction[x][1][0]]
if not(os.path.exists(os.path.join(directory, str(x)+'.jpg'))):
cv2.imwrite(os.path.join(directory, str(x)+'.jpg'), cropped_image)
et[str(x)] = os.path.join(directory, str(x)+'.jpg')
for root, dirs, files in os.walk(directory):
for x in files:
try:
img = Image.open((root+"\\"+ x).strip())
text = self.mocr(img)
ts[(root+"\\"+ x).strip()] = text
except:
print("not pic")
mg = et.items()
tg = ts.items()
for coor, direct in mg:
for dir1, jap in tg:
if direct == dir1:
newList[coor] = jap
return newList
#chronos
def translate(self, original):
for jap in original:
original[jap] = str(ts.bing(original[jap]))
return original
def segment(self, list1):
for line in list1:
newL= list(str(list1[line]))
s = ''
count = 0
for x in range(len(newL)):
if newL[x] == " ":
count += 1
if count == 3:
newL[x] = "\n"
count = 0
s += newL[x]
list1[line] = s
return list1
def write(self, img, dict1, list1):
fontSize = .5
# if img.shape > (1200, 851, 3):
# fontSize *= 10
for value in dict1:
cv2.rectangle(img, dict1[value][0], dict1[value][1], (0, 255, 255), 2)
image = add_text_to_image(
img,
list1[value],
font_color_rgb=(255, 0, 0),
top_left_xy=(dict1[value][0][0], dict1[value][1][1]),
font_scale= fontSize,
font_face=cv2.FONT_HERSHEY_DUPLEX
)
return image
# plt.rcParams['figure.figsize'] = (16,16)
# plt.imshow(image)
# plt.show()
def run(self):
gotten_text = self.get_text(self.image)
finalText = self.get_japanese(gotten_text)
newList = self.translate(finalText)
addNewLine = self.segment(newList)
final = self.write(self.image, gotten_text, addNewLine)
self.finished.emit(final)
When I run the program, both in the IDE and terminal, I don't get any errors, I just get:
<function Translate.get_text at 0x0000013C5D880B80> took 10.577515602111816 seconds
<function Translate.get_japanese at 0x0000013C5DA03E50> took 6.2078752517700195 seconds
<function Translate.translate at 0x0000013C5DA03EE0> took 8.287482023239136 seconds
THREAD COMPLETE!

Problem to display QLabels in GridLayout in PyQt5?

My Intention is to display five types of labels in two frames (left and right Frame).
In my case, the right frame, which contains two labels, is displayed or added as per my idea.
But in the Left frame, I face a problem. Added widgets display is not proper. The left frame is a GridLayout, In which we add three widgets. As of my idea, top widget is none or single line. Middle widget is a character and the bottim widget is either single, double or triple line.
import sys
from PyQt5.QtWidgets import QWidget,QFrame,QLabel,QHBoxLayout,QVBoxLayout,QGridLayout,QApplication
from PyQt5.QtCore import Qt
from PyQt5.QtGui import QFont
class Left_Right_FrameDesign(QWidget):
def __init__(self,color_left_lrcd,color_right_lrcd,
frame_left_lrcd_width,frame_right_lrcd_width,
frame_lrcd_height):
super().__init__()
self.color_left_lrcd = color_left_lrcd
self.color_right_lrcd = color_right_lrcd
self.frame_left_lrcd_width = frame_left_lrcd_width
self.frame_right_lrcd_width = frame_right_lrcd_width
self.frame_lrcd_height = frame_lrcd_height
self.frame_left_lrcd = QFrame()
self.frame_left_lrcd.setProperty("type","1")
self.frame_left_lrcd.setFixedSize(self.frame_left_lrcd_width,self.frame_lrcd_height)
self.frame_right_lrcd = QFrame()
self.frame_right_lrcd.setProperty("type","1")
self.frame_right_lrcd.setFixedHeight(self.frame_lrcd_height)
self.frame_right_lrcd.setFixedWidth(self.frame_right_lrcd_width)
self.principal_lrcd_layout = QHBoxLayout()
self.frame_left_lrcd_layout = QGridLayout(self.frame_left_lrcd)
self.frame_right_lrcd_layout = QVBoxLayout(self.frame_right_lrcd)
self.frame_left_lrcd_layout.setContentsMargins(0, 0, 0, 0)
self.frame_right_lrcd_layout.setContentsMargins(0,0,0,0)
self.frame_right_lrcd_layout.setSpacing(0)
self.frame_left_lrcd_layout.setAlignment(Qt.AlignHCenter| Qt.AlignVCenter)
self.principal_lrcd_layout.setSpacing(0)
self.principal_lrcd_layout.addWidget(self.frame_left_lrcd)
self.principal_lrcd_layout.addWidget(self.frame_right_lrcd)
self.principal_lrcd_layout.setContentsMargins(0, 0, 0, 0)
class example(QWidget):
def __init__(self):
super().__init__()
self.setWindowTitle("My Widget Example")
self.setStyleSheet(style_sheet())
my_font_1 = QFont("Arial", 10, QFont.Bold)
my_font_1.setLetterSpacing(QFont.AbsoluteSpacing, -6)
my_font_en = QFont("Arial", 8, QFont.Bold)
my_font_hi = QFont("Mangal", 11, )
my_font_ta = QFont("Latha", 8,QFont.Bold)
lbl_sline = ('\u2015' * 1) # print single line
lbl_dline = '\u003D' * 4 # print double line
lbl_tline = ('\u2261' * 4) # print tripleline
text = {"lbl01": {"lan_1":"en_Accounts","lan_2":"ta_கணக்கியல்" ,"char":"ta_ழ்","top_line":"0","bot_line":"1"},
"lbl02": {"lan_1":"en_Manufacturing","lan_2":"hi_हिसाब किताब","char":"en_F8","top_line":"1","bot_line":"2"},
"lbl03": {"lan_1":"en_Inventory","lan_2":"ta_சரக்கியல்" ,"char":"hi_हि","top_line":"1","bot_line":"3"}}
lst_mainkeys = list(text.keys())
lst_subkeys = list(text[lst_mainkeys[0]].keys())
self.frame_design,self.lbl_lan1,self.lbl_lan2,self.lbl_tline,self.lbl_char,self.lbl_bline = {},{},{},{},{},{}
self.lay = QHBoxLayout()
self.lay.setSpacing(3)
self.lay.setContentsMargins(0, 0, 0, 0)
for i, j in enumerate(lst_mainkeys):
self.frame_design[i] = Left_Right_FrameDesign(color_left_lrcd="green", color_right_lrcd="blue",
frame_left_lrcd_width=50, frame_right_lrcd_width=200,
frame_lrcd_height= 40)
for m,n in enumerate(lst_subkeys):
name = j+"_"+str(m)
self.lbl_lan1[name] = QLabel()
self.lbl_lan2[name] = QLabel()
self.lbl_tline[name] = QLabel()
self.lbl_char[name] = QLabel()
self.lbl_bline[name] = QLabel()
self.temp_name =(text[j][n])
if self.temp_name[:2] == "en":
self.myfont = my_font_en
elif self.temp_name[:2] == "ta":
self.myfont = my_font_ta
elif self.temp_name[:2] == "hi":
self.myfont = my_font_hi
if n == "lan_1":
self.lbl_lan1[name].setText(text[j][n][3:])
self.lbl_lan1[name].setFont(self.myfont)
self.frame_design[i].frame_right_lrcd_layout.addWidget(self.lbl_lan1[name])
elif n == "lan_2":
self.lbl_lan2[name].setText(text[j][n][3:])
self.lbl_lan2[name].setFont(self.myfont)
self.frame_design[i].frame_right_lrcd_layout.addWidget(self.lbl_lan2[name])
elif n == "char":
self.lbl_char[name].setText(text[j][n][3:])
self.lbl_char[name].setFont(self.myfont)
self.frame_design[i].frame_left_lrcd_layout.addWidget(self.lbl_char[name],1,0)
if n == "top_line":
if self.temp_name == 0:
pass
elif self.temp_name == 1:
self.lbl_tline[name].setText(lbl_sline)
self.frame_design[i].frame_left_lrcd_layout.addWidget(self.lbl_tline[name],0,0)
if n == "bot_line":
if self.temp_name == 1:
self.lbl_bline[name].setText(lbl_sline)
elif self.temp_name == 2:
self.lbl_bline[name].setText(lbl_dline)
elif self.temp_name == 3:
self.lbl_bline[name].setText(lbl_tline)
self.lbl_bline[name].setText(text[j][n])
self.frame_design[i].frame_left_lrcd_layout.addWidget(self.lbl_bline[name],2,0)
self.lay.addLayout(self.frame_design[i].principal_lrcd_layout)
self.setLayout(self.lay)
def style_sheet():
return """
QFrame[type="1"] {background-color : rgb(188,212,114);}
QFrame[type="1"]::hover{background-color:rgb(255, 223, 0);color: Black;}}"""
if __name__ =="__main__":
app = QApplication(sys.argv)
mainwindow = example()
mainwindow.show()
sys.exit(app.exec_())

PyQt5 QSlider two positions

I want the user to select two frequencies: one low frequency and one high frequency.
Can I make this with one QSlider?
I found this page: https://doc.qt.io/qt-5/qtwidgets-widgets-sliders-example.html but it hasn't something that can I use for this goal.

file range_slider.py
#!/usr/bin/python3
# -*- coding: utf-8 -*-
import sys, os
from PyQt5 import QtCore, QtGui, QtWidgets
# Originated from
# https://www.mail-archive.com/pyqt#riverbankcomputing.com/msg22889.html
# Modification refered from
# https://gist.github.com/Riateche/27e36977f7d5ea72cf4f
class RangeSlider(QtWidgets.QSlider):
sliderMoved = QtCore.pyqtSignal(int, int)
""" A slider for ranges.
This class provides a dual-slider for ranges, where there is a defined
maximum and minimum, as is a normal slider, but instead of having a
single slider value, there are 2 slider values.
This class emits the same signals as the QSlider base class, with the
exception of valueChanged
"""
def __init__(self, *args):
super(RangeSlider, self).__init__(*args)
self._low = self.minimum()
self._high = self.maximum()
self.pressed_control = QtWidgets.QStyle.SC_None
self.tick_interval = 0
self.tick_position = QtWidgets.QSlider.NoTicks
self.hover_control = QtWidgets.QStyle.SC_None
self.click_offset = 0
# 0 for the low, 1 for the high, -1 for both
self.active_slider = 0
def low(self):
return self._low
def setLow(self, low:int):
self._low = low
self.update()
def high(self):
return self._high
def setHigh(self, high):
self._high = high
self.update()
def paintEvent(self, event):
# based on http://qt.gitorious.org/qt/qt/blobs/master/src/gui/widgets/qslider.cpp
painter = QtGui.QPainter(self)
style = QtWidgets.QApplication.style()
# draw groove
opt = QtWidgets.QStyleOptionSlider()
self.initStyleOption(opt)
opt.siderValue = 0
opt.sliderPosition = 0
opt.subControls = QtWidgets.QStyle.SC_SliderGroove
if self.tickPosition() != self.NoTicks:
opt.subControls |= QtWidgets.QStyle.SC_SliderTickmarks
style.drawComplexControl(QtWidgets.QStyle.CC_Slider, opt, painter, self)
groove = style.subControlRect(QtWidgets.QStyle.CC_Slider, opt, QtWidgets.QStyle.SC_SliderGroove, self)
# drawSpan
#opt = QtWidgets.QStyleOptionSlider()
self.initStyleOption(opt)
opt.subControls = QtWidgets.QStyle.SC_SliderGroove
#if self.tickPosition() != self.NoTicks:
# opt.subControls |= QtWidgets.QStyle.SC_SliderTickmarks
opt.siderValue = 0
#print(self._low)
opt.sliderPosition = self._low
low_rect = style.subControlRect(QtWidgets.QStyle.CC_Slider, opt, QtWidgets.QStyle.SC_SliderHandle, self)
opt.sliderPosition = self._high
high_rect = style.subControlRect(QtWidgets.QStyle.CC_Slider, opt, QtWidgets.QStyle.SC_SliderHandle, self)
#print(low_rect, high_rect)
low_pos = self.__pick(low_rect.center())
high_pos = self.__pick(high_rect.center())
min_pos = min(low_pos, high_pos)
max_pos = max(low_pos, high_pos)
c = QtCore.QRect(low_rect.center(), high_rect.center()).center()
#print(min_pos, max_pos, c)
if opt.orientation == QtCore.Qt.Horizontal:
span_rect = QtCore.QRect(QtCore.QPoint(min_pos, c.y()-2), QtCore.QPoint(max_pos, c.y()+1))
else:
span_rect = QtCore.QRect(QtCore.QPoint(c.x()-2, min_pos), QtCore.QPoint(c.x()+1, max_pos))
#self.initStyleOption(opt)
#print(groove.x(), groove.y(), groove.width(), groove.height())
if opt.orientation == QtCore.Qt.Horizontal: groove.adjust(0, 0, -1, 0)
else: groove.adjust(0, 0, 0, -1)
if True: #self.isEnabled():
highlight = self.palette().color(QtGui.QPalette.Highlight)
painter.setBrush(QtGui.QBrush(highlight))
painter.setPen(QtGui.QPen(highlight, 0))
#painter.setPen(QtGui.QPen(self.palette().color(QtGui.QPalette.Dark), 0))
'''
if opt.orientation == QtCore.Qt.Horizontal:
self.setupPainter(painter, opt.orientation, groove.center().x(), groove.top(), groove.center().x(), groove.bottom())
else:
self.setupPainter(painter, opt.orientation, groove.left(), groove.center().y(), groove.right(), groove.center().y())
'''
#spanRect =
painter.drawRect(span_rect.intersected(groove))
#painter.drawRect(groove)
for i, value in enumerate([self._low, self._high]):
opt = QtWidgets.QStyleOptionSlider()
self.initStyleOption(opt)
# Only draw the groove for the first slider so it doesn't get drawn
# on top of the existing ones every time
if i == 0:
opt.subControls = QtWidgets.QStyle.SC_SliderHandle# | QtWidgets.QStyle.SC_SliderGroove
else:
opt.subControls = QtWidgets.QStyle.SC_SliderHandle
if self.tickPosition() != self.NoTicks:
opt.subControls |= QtWidgets.QStyle.SC_SliderTickmarks
if self.pressed_control:
opt.activeSubControls = self.pressed_control
else:
opt.activeSubControls = self.hover_control
opt.sliderPosition = value
opt.sliderValue = value
style.drawComplexControl(QtWidgets.QStyle.CC_Slider, opt, painter, self)
def mousePressEvent(self, event):
event.accept()
style = QtWidgets.QApplication.style()
button = event.button()
# In a normal slider control, when the user clicks on a point in the
# slider's total range, but not on the slider part of the control the
# control would jump the slider value to where the user clicked.
# For this control, clicks which are not direct hits will slide both
# slider parts
if button:
opt = QtWidgets.QStyleOptionSlider()
self.initStyleOption(opt)
self.active_slider = -1
for i, value in enumerate([self._low, self._high]):
opt.sliderPosition = value
hit = style.hitTestComplexControl(style.CC_Slider, opt, event.pos(), self)
if hit == style.SC_SliderHandle:
self.active_slider = i
self.pressed_control = hit
self.triggerAction(self.SliderMove)
self.setRepeatAction(self.SliderNoAction)
self.setSliderDown(True)
break
if self.active_slider < 0:
self.pressed_control = QtWidgets.QStyle.SC_SliderHandle
self.click_offset = self.__pixelPosToRangeValue(self.__pick(event.pos()))
self.triggerAction(self.SliderMove)
self.setRepeatAction(self.SliderNoAction)
else:
event.ignore()
def mouseMoveEvent(self, event):
if self.pressed_control != QtWidgets.QStyle.SC_SliderHandle:
event.ignore()
return
event.accept()
new_pos = self.__pixelPosToRangeValue(self.__pick(event.pos()))
opt = QtWidgets.QStyleOptionSlider()
self.initStyleOption(opt)
if self.active_slider < 0:
offset = new_pos - self.click_offset
self._high += offset
self._low += offset
if self._low < self.minimum():
diff = self.minimum() - self._low
self._low += diff
self._high += diff
if self._high > self.maximum():
diff = self.maximum() - self._high
self._low += diff
self._high += diff
elif self.active_slider == 0:
if new_pos >= self._high:
new_pos = self._high - 1
self._low = new_pos
else:
if new_pos <= self._low:
new_pos = self._low + 1
self._high = new_pos
self.click_offset = new_pos
self.update()
#self.emit(QtCore.SIGNAL('sliderMoved(int)'), new_pos)
self.sliderMoved.emit(self._low, self._high)
def __pick(self, pt):
if self.orientation() == QtCore.Qt.Horizontal:
return pt.x()
else:
return pt.y()
def __pixelPosToRangeValue(self, pos):
opt = QtWidgets.QStyleOptionSlider()
self.initStyleOption(opt)
style = QtWidgets.QApplication.style()
gr = style.subControlRect(style.CC_Slider, opt, style.SC_SliderGroove, self)
sr = style.subControlRect(style.CC_Slider, opt, style.SC_SliderHandle, self)
if self.orientation() == QtCore.Qt.Horizontal:
slider_length = sr.width()
slider_min = gr.x()
slider_max = gr.right() - slider_length + 1
else:
slider_length = sr.height()
slider_min = gr.y()
slider_max = gr.bottom() - slider_length + 1
return style.sliderValueFromPosition(self.minimum(), self.maximum(),
pos-slider_min, slider_max-slider_min,
opt.upsideDown)
Usage:
#!/usr/bin/python3
# -*- coding: utf-8 -*-
import sys, os
from PyQt5 import QtCore, QtGui, QtWidgets
import range_slider
def echo(low_value, high_value):
print(low_value, high_value)
def main(argv):
app = QtWidgets.QApplication(sys.argv)
slider = range_slider.RangeSlider(QtCore.Qt.Horizontal)
slider.setMinimumHeight(30)
slider.setMinimum(0)
slider.setMaximum(255)
slider.setLow(15)
slider.setHigh(35)
slider.setTickPosition(QtWidgets.QSlider.TicksBelow)
slider.sliderMoved.connect(echo)
#QtCore.QObject.connect(slider, QtCore.SIGNAL('sliderMoved(int)'), echo)
slider.show()
slider.raise_()
app.exec_()
if __name__ == "__main__":
main(sys.argv)
link: https://github.com/Qt-Widgets/range_slider_for_Qt5_and_PyQt5/blob/master/pyqt5_ranger_slider/main.py

Does PyQt5 have a transition effect like Kivy

Kivy Gui have a transition animation to switch between windows (going back and forth also) we can do it easily in kivy. But in PyQt5 I did't find out any way to transit between window (with animation) and going back and forth to a window again and again is also not working. So, is there any way to do like Kivy do transitions, going back and forth to a window easily in PyQt5.

Qt doesn't provide a similar effect on its own, but it still can be achieved using a subclass of a QStackedWidget (which behaves similarly to a QTabWidget, but without any QTabBar).
In the following example I'll show you how to implement a basic "swap" transition between two widgets that are added to a QStackedWidget, the next widget will scroll from right to left if the index is greater than the current, and vice versa.
class TransitionWidget(QtWidgets.QStackedWidget):
_nextIndex = _nextWidget = None
_orientation = QtCore.Qt.Horizontal
def __init__(self):
super().__init__()
self._animation = QtCore.QVariantAnimation(
startValue=0., endValue=1., duration=250)
self._animation.valueChanged.connect(self._aniUpdate)
self._animation.finished.connect(self._aniFinished)
self._animation.setEasingCurve(QtCore.QEasingCurve.InOutQuart)
def setDuration(self, duration):
self._animation.setDuration(duration)
def setCurve(self, curve):
if isinstance(curve, QtCore.QEasingCurve):
self._animation.setEasingCurve(curve)
def setOrientation(self, orientation):
self._orientation = orientation
def getRange(self, prevIndex, nextIndex):
rect = self.rect()
currentStart = nextEnd = QtCore.QPoint()
if self._orientation == QtCore.Qt.Horizontal:
if prevIndex < nextIndex:
currentEnd = QtCore.QPoint(-rect.width(), 0)
nextStart = QtCore.QPoint(rect.width(), 0)
else:
currentEnd = QtCore.QPoint(rect.width(), 0)
nextStart = QtCore.QPoint(-rect.width(), 0)
else:
if prevIndex < nextIndex:
currentEnd = QtCore.QPoint(0, -rect.width())
nextStart = QtCore.QPoint(0, rect.width())
else:
currentEnd = QtCore.QPoint(0, rect.width())
nextStart = QtCore.QPoint(0, -rect.width())
return currentStart, currentEnd, nextStart, nextEnd
def setCurrentIndex(self, index):
if index == self.currentIndex():
return
# prepare the next widget changes
if self._nextWidget is not None:
self._nextWidget.hide()
self._nextIndex = index
self._nextWidget = self.widget(index)
self._nextWidget.show()
rect = self.rect()
rect.translate(self.rect().topRight())
self._nextWidget.setGeometry(rect)
self._nextWidget.raise_()
self._animation.start()
def _aniFinished(self):
super().setCurrentIndex(self._nextIndex)
self._nextIndex = self._nextWidget = None
def _aniUpdate(self, value):
if not self._animation.state():
return
currentStart, currentEnd, nextStart, nextEnd = self.getRange(self.currentIndex(), self._nextIndex)
rect = self.rect()
self.currentWidget().setGeometry(rect.translated(QtCore.QLineF(currentStart, currentEnd).pointAt(value).toPoint()))
self._nextWidget.setGeometry(rect.translated(QtCore.QLineF(nextStart, nextEnd).pointAt(value).toPoint()))
self.update()
Example code:
if __name__ == '__main__':
import sys
app = QtWidgets.QApplication(sys.argv)
mainWidget = QtWidgets.QWidget()
mainLayout = QtWidgets.QHBoxLayout(mainWidget)
transitionWidget = TransitionWidget()
mainLayout.addWidget(transitionWidget)
pageCount = 10
for page in range(pageCount):
widget = QtWidgets.QWidget()
layout = QtWidgets.QGridLayout(widget)
pageLabel = QtWidgets.QLabel('Page {}'.format(page + 1))
layout.addWidget(pageLabel, 0, 0, 1, 2)
prevBtn = QtWidgets.QPushButton('Previous')
if not page:
prevBtn.setEnabled(False)
layout.addWidget(prevBtn)
nextBtn = QtWidgets.QPushButton('Next')
layout.addWidget(nextBtn)
if page == pageCount - 1:
nextBtn.setEnabled(False)
transitionWidget.addWidget(widget)
prevBtn.clicked.connect(lambda _, page=page: transitionWidget.setCurrentIndex(page - 1))
nextBtn.clicked.connect(lambda _, page=page: transitionWidget.setCurrentIndex(page + 1))
sep = QtWidgets.QFrame(frameShape=QtWidgets.QFrame.VLine)
mainLayout.addWidget(sep)
orientationCombo = QtWidgets.QComboBox()
orientationLayout = QtWidgets.QFormLayout()
mainLayout.addLayout(orientationLayout)
orientationCombo.addItems(['Horizontal', 'Vertical'])
orientationCombo.currentIndexChanged.connect(lambda o: transitionWidget.setOrientation(o + 1))
orientationLayout.addRow('Orientation', orientationCombo)
durationSpin = QtWidgets.QSpinBox(minimum=50, maximum=1000, singleStep=50, suffix='ms')
orientationLayout.addRow('Duration', durationSpin)
durationSpin.setValue(transitionWidget._animation.duration())
durationSpin.valueChanged.connect(transitionWidget.setDuration)
mainWidget.show()
sys.exit(app.exec_())

Is there a way to implement a circular waiting indicator using PyQt?

I am trying to build an application using PyQt. A part of the application runs a thread which takes some time to complete. How can I add a waiting indicator (preferably circular) to indicate running of the process?
I know I can go with a progress bar, or perhaps a splash screen. I have looked into both but I am trying to opt for one of them only as a last resort. Can someone please help me with this?
Thank You

I have converted the code from the QtWaitingSpinner from C ++ to PyQt4/PyQt5
from math import ceil
"""from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *"""
from PyQt4.QtCore import *
from PyQt4.QtGui import *
class QtWaitingSpinner(QWidget):
mColor = QColor(Qt.gray)
mRoundness = 100.0
mMinimumTrailOpacity = 31.4159265358979323846
mTrailFadePercentage = 50.0
mRevolutionsPerSecond = 1.57079632679489661923
mNumberOfLines = 20
mLineLength = 10
mLineWidth = 2
mInnerRadius = 20
mCurrentCounter = 0
mIsSpinning = False
def __init__(self, centerOnParent=True, disableParentWhenSpinning=True, *args, **kwargs):
QWidget.__init__(self, *args, **kwargs)
self.mCenterOnParent = centerOnParent
self.mDisableParentWhenSpinning = disableParentWhenSpinning
self.initialize()
def initialize(self):
self.timer = QTimer(self)
self.timer.timeout.connect(self.rotate)
self.updateSize()
self.updateTimer()
self.hide()
#pyqtSlot()
def rotate(self):
self.mCurrentCounter += 1
if self.mCurrentCounter > self.numberOfLines():
self.mCurrentCounter = 0
self.update()
def updateSize(self):
size = (self.mInnerRadius + self.mLineLength) * 2
self.setFixedSize(size, size)
def updateTimer(self):
self.timer.setInterval(1000 / (self.mNumberOfLines * self.mRevolutionsPerSecond))
def updatePosition(self):
if self.parentWidget() and self.mCenterOnParent:
self.move(self.parentWidget().width() / 2 - self.width() / 2,
self.parentWidget().height() / 2 - self.height() / 2)
def lineCountDistanceFromPrimary(self, current, primary, totalNrOfLines):
distance = primary - current
if distance < 0:
distance += totalNrOfLines
return distance
def currentLineColor(self, countDistance, totalNrOfLines, trailFadePerc, minOpacity, color):
if countDistance == 0:
return color
minAlphaF = minOpacity / 100.0
distanceThreshold = ceil((totalNrOfLines - 1) * trailFadePerc / 100.0)
if countDistance > distanceThreshold:
color.setAlphaF(minAlphaF)
else:
alphaDiff = self.mColor.alphaF() - minAlphaF
gradient = alphaDiff / distanceThreshold + 1.0
resultAlpha = color.alphaF() - gradient * countDistance
resultAlpha = min(1.0, max(0.0, resultAlpha))
color.setAlphaF(resultAlpha)
return color
def paintEvent(self, event):
self.updatePosition()
painter = QPainter(self)
painter.fillRect(self.rect(), Qt.transparent)
painter.setRenderHint(QPainter.Antialiasing, True)
if self.mCurrentCounter > self.mNumberOfLines:
self.mCurrentCounter = 0
painter.setPen(Qt.NoPen)
for i in range(self.mNumberOfLines):
painter.save()
painter.translate(self.mInnerRadius + self.mLineLength,
self.mInnerRadius + self.mLineLength)
rotateAngle = 360.0 * i / self.mNumberOfLines
painter.rotate(rotateAngle)
painter.translate(self.mInnerRadius, 0)
distance = self.lineCountDistanceFromPrimary(i, self.mCurrentCounter,
self.mNumberOfLines)
color = self.currentLineColor(distance, self.mNumberOfLines,
self.mTrailFadePercentage, self.mMinimumTrailOpacity, self.mColor)
painter.setBrush(color)
painter.drawRoundedRect(QRect(0, -self.mLineWidth // 2, self.mLineLength, self.mLineLength),
self.mRoundness, Qt.RelativeSize)
painter.restore()
def start(self):
self.updatePosition()
self.mIsSpinning = True
self.show()
if self.parentWidget() and self.mDisableParentWhenSpinning:
self.parentWidget().setEnabled(False)
if not self.timer.isActive():
self.timer.start()
self.mCurrentCounter = 0
def stop(self):
self.mIsSpinning = False
self.hide()
if self.parentWidget() and self.mDisableParentWhenSpinning:
self.parentWidget().setEnabled(True)
if self.timer.isActive():
self.timer.stop()
self.mCurrentCounter = 0
def setNumberOfLines(self, lines):
self.mNumberOfLines = lines
self.updateTimer()
def setLineLength(self, length):
self.mLineLength = length
self.updateSize()
def setLineWidth(self, width):
self.mLineWidth = width
self.updateSize()
def setInnerRadius(self, radius):
self.mInnerRadius = radius
self.updateSize()
def color(self):
return self.mColor
def roundness(self):
return self.mRoundness
def minimumTrailOpacity(self):
return self.mMinimumTrailOpacity
def trailFadePercentage(self):
return self.mTrailFadePercentage
def revolutionsPersSecond(self):
return self.mRevolutionsPerSecond
def numberOfLines(self):
return self.mNumberOfLines
def lineLength(self):
return self.mLineLength
def lineWidth(self):
return self.mLineWidth
def innerRadius(self):
return self.mInnerRadius
def isSpinning(self):
return self.mIsSpinning
def setRoundness(self, roundness):
self.mRoundness = min(0.0, max(100, roundness))
def setColor(self, color):
self.mColor = color
def setRevolutionsPerSecond(self, revolutionsPerSecond):
self.mRevolutionsPerSecond = revolutionsPerSecond
self.updateTimer()
def setTrailFadePercentage(self, trail):
self.mTrailFadePercentage = trail
def setMinimumTrailOpacity(self, minimumTrailOpacity):
self.mMinimumTrailOpacity = minimumTrailOpacity
if __name__ == '__main__':
import sys
app = QApplication(sys.argv)
dial = QDialog()
w = QtWaitingSpinner(dial)
dial.show()
w.start()
QTimer.singleShot(1000, w.stop)
sys.exit(app.exec_())
In the following link you can find a complete example

In addition to the above response...
If you are using Qt Designer you'll need to create a QWidget and promote it to a QtWaitingSpinner. You can follow this for promoting QWidgets. In this case, your Promoted Class name is QtWaitingSpinner and Header file is the file where the QtWaitingSpinner class is located.
Once your GUI is set you can call
your_QtWaitingSpinnerObject.start()