Develop Reference

Pushing QWidget Window to topmost in Python

I'm new to Python and have mostly learnt C# in the past. I am creating a QWidget class:
class Window(QWidget):
def __init__(self, gif, width, height):
super().__init__()
self.setGeometry(400, 200, width, height)
self.setWindowTitle("Python Run GIF Images")
self.setWindowIcon(QIcon('icons/qt.png'))
label = QLabel(self)
movie = QMovie(gif)
label.setMovie(movie)
movie.start()
And then define a function that creates a QApplication and then the Window:
def run_gif(gif, width, height):
app = QApplication([])
window = Window(gif, width, height)
window.show()
app.exec()
app.shutdown()
My issue is getting the gif to show topmost when it is launched. There is a Topmost property you can set on a Winform in C# which means no other window or other app you click on will cover the Window. This isn't essential but I want it to at least be shown above the code editor it is launched from so that the user doesn't have to select the Window to see the gif contained in the Window. I've spent hours looking at properties I can set either in the class or the method and not getting the result I need.
However, when I call the run_gif method for the second time, it does show it topmost, but along with the below exception (at least I think it's an exception from what I'm reading, it doesn't affect the running of the program other than printing to the console).
QApplication::regClass: Registering window class 'Qt640ScreenChangeObserverWindow' failed. (Class already exists.)
The only advice I can find on this error is not Python-specific and I don't really understand it. Maybe I'm being a bit ambitious for my early stage learning Python but not really seeing anything much on this error.
This is using PySide6.

Using setWindowFlag(Qt.WindowType.WindowStaysOnTopHint, True) seems to be working for me so far.
Example:
from PySide6.QtWidgets import *
from PySide6.QtCore import *
from PySide6.QtGui import *
class Window(QWidget):
def __init__(self, parent=None):
super().__init__(parent=parent)
self.layout = QVBoxLayout(self)
self.resize(200,100)
self.label = QLabel("Always on top...")
self.layout.addWidget(self.label)
self.setWindowFlag(Qt.WindowType.WindowStaysOnTopHint, True) # <--
if __name__ == '__main__':
app = QApplication([])
window = Window()
window.show()
app.exec()

Get width of vertical QHeaderView [duplicate]

I am currently developing an application in which i cannot use modal windows (due to some application constraints). However, in some cases i would like to simulate a popup window. To do so i dynamically create a widget that has the centralwidget as parent and i use the move() method to place it where i want.
I would like to know if there is a way to get a widget's dimensions at a given time (considering the mainWindow can be resized at any time) so that i will be able to center the placeholder popup (a simple widget) at the middle of the centralwidget.
Thank you

For getting Qt Widget size:
import sys
from PyQt4 import QtGui, QtCore
app = QtGui.QApplication(sys.argv)
mainWindow = QtGui.QWidget()
width = mainWindow.frameGeometry().width()
height = mainWindow.frameGeometry().height()

For gettting screen size
import sys
from PyQt4 import QtGui, QtCore
app = QtGui.QApplication(sys.argv)
mainWindow = QtGui.QWidget()
screenShape = QtGui.QDesktopWidget().screenGeometry()
mainWindow.resize(self.screenShape.width(), self.screenShape.height())
mainWindow.show()

You can use frameGeometry or geometry depending on your needs.

How to display image on secondary monitor in full screen?

How can I use PyQt5/PySide or any other Python library to display a desired image on a secondary monitor in full-screen mode? In the past, I used a framebuffer image viewer (Fbi and Fbi improved). However, this approach requires me to use Linux. I prefer to work in Windows and preferably find a solution using Python.
Motivation/Context
I am working on a DLP projection based 3D printing process. When I connect a DLP projector to my Windows PC using HDMI, it shows up as a second monitor. I want to dedicate this secondary monitor (DLP) only to display my desired patterns images (png, bmp, or svg) for the 3D printing process. I would like to programmatically control using Python which image is being displayed.
This is a followup question to https://3dprinting.stackexchange.com/questions/1217/how-to-display-images-on-dlp-using-hdmi-for-3d-printing
Partial solution and issues
Below code is one possible solution, however I am unsure if its the correct or the most efficient approach. I found two approaches using PyQt5: 1) using splash screen, and 2) using QLabel. I am facing the following issues with my code:
Cursor is hidden as expected, however if I accidentally click mouse on secondary screen, the splash screen closes.
If I use the QLabel approach, I see a white screen appear and then my image gets loaded. There is a distinct delay of ~ 0.5-1s from the time white screen appears to when the actual image is displayed.
If the images are displayed in high frequency (ex: every 1 sec), this code doesn't work well. For example, in the code change the total_loops=1 to total_loops=25. When using splash screen method, I see the splash screen appear on the main screen then it moves to the secondary screen. When using the QLabel method, all I see is a white screen appear, and only the last iteration the image is displayed. In addition, the window of the QLabel becomes active on the main screen and is visible in the Task bar.
How do I handle a situation if I want to display a video instead of an image?
For 3D printing application, the solution needs to meet the following requirement:
Secondary screen is the DLP projector, and it should NOT contain any OS related windows/taskbars/etc...
No cursor/mouse or other applications should appear on the the secondary screen
Images/videos need to be displayed in fullscreen mode
When displaying or updating images on the secondary screen, there should be no disturbance on the primary screen. For example, the image window in secondary screen shouldn't take focus away from currently active window in the primary screen
import time
start_time = time.time()
import sys
from PyQt5.QtWidgets import QApplication, QLabel, QSplashScreen
from PyQt5.QtGui import QPixmap, QCursor
from PyQt5.QtCore import Qt
import os
app = QApplication(sys.argv)
total_loops = 1
for i in range(total_loops):
# https://doc.qt.io/qtforpython/index.html
# https://www.riverbankcomputing.com/static/Docs/PyQt5/module_index.html
s = app.screens()[1] # Get the secondary screen
# Display info about secondary screen
print('Screen Name: {} Size: {}x{} Available geometry {}x{} '.format(s.name(), s.size().width(), s.size().height(), s.availableGeometry().width(), s.availableGeometry().height()))
# Hide cursor from appearing on screen
app.setOverrideCursor(QCursor(Qt.BlankCursor)) # https://forum.qt.io/topic/49877/hide-cursor
# Select desired image to be displayed
pixmap = QPixmap('test.png')
# Splash screen approach
# https://doc.qt.io/qtforpython/PySide2/QtWidgets/QSplashScreen.html?highlight=windowflags
splash = QSplashScreen(pixmap) # Set the splash screen to desired image
splash.show() # Show the splash screen
splash.windowHandle().setScreen(s) # Set splash screen to secondary monitor https://stackoverflow.com/a/30597458/4988010
splash.showFullScreen() # Show in splash screen in full screen mode
# # Qlabel apporach
# l = QLabel()
# l.setPixmap(pixmap)
# l.move(1920,0)
# l.show()
# l.windowHandle().setScreen(s) # https://stackoverflow.com/a/30597458/4988010
# l.showFullScreen()
time.sleep(0.5)
end_time = time.time()
print('Execution time: ', end_time-start_time )
sys.exit(app.exec_())

The code below is one possible solution to my question. My solution assumes that Qt is only used to display the images in full-screen and not for the remaining logic. Therefore, I had to run the QT app in a secondary thread. This is because the moment I run the function app.exec_(), Qt will continuously run an event loop thus blocking the rest of my Python logic which does NOT rely on Qt. It is my understanding running QApplication outside of a main thread is not recommended, therefore I would welcome a more experienced user to post a better approach.
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from PyQt5.QtCore import QObject, pyqtSignal
import sys
import time
import threading
def main():
print('Step 1')
print(' Some logic here without QT')
print('Step 2')
print(' Launch QT app to run in background')
myapp = myImageDisplayApp()
print('Step 3')
print(' Continue some logic while QT running in background')
time.sleep(2)
print('Step 4')
print(' Update the displayed image in the QT app running in background')
myapp.emit_image_update('qt_test_static_1.png')
time.sleep(2)
print('Step 5')
print(' Update displayed image again')
myapp.emit_image_update('qt_test_static_2.png')
time.sleep(2)
class myImageDisplayApp (QObject):
# Define the custom signal
# https://www.riverbankcomputing.com/static/Docs/PyQt5/signals_slots.html#the-pyqtslot-decorator
signal_update_image = pyqtSignal(str)
def __init__ (self):
super().__init__()
# Setup the seperate thread
# https://stackoverflow.com/a/37694109/4988010
self.thread = threading.Thread(target=self.run_app_widget_in_background)
self.thread.daemon = True
self.thread.start()
def run_app_widget_in_background(self):
self.app = QApplication(sys.argv)
self.my_bg_qt_app = qtAppWidget(main_thread_object=self)
self.app.exec_()
def emit_image_update(self, pattern_file=None):
print('emit_image_update signal')
self.signal_update_image.emit(pattern_file)
class qtAppWidget (QLabel):
def __init__ (self, main_thread_object):
super().__init__()
# Connect the singal to slot
main_thread_object.signal_update_image.connect(self.updateImage)
self.setupGUI()
def setupGUI(self):
self.app = QApplication.instance()
# Get avaliable screens/monitors
# https://doc.qt.io/qt-5/qscreen.html
# Get info on selected screen
self.selected_screen = 0 # Select the desired monitor/screen
self.screens_available = self.app.screens()
self.screen = self.screens_available[self.selected_screen]
self.screen_width = self.screen.size().width()
self.screen_height = self.screen.size().height()
# Create a black image for init
self.pixmap = QPixmap(self.screen_width, self.screen_height)
self.pixmap.fill(QColor('black'))
# Create QLabel object
self.app_widget = QLabel()
# Varioius flags that can be applied to make displayed window frameless, fullscreen, etc...
# https://doc.qt.io/qt-5/qt.html#WindowType-enum
# https://doc.qt.io/qt-5/qt.html#WidgetAttribute-enum
self.app_widget.setWindowFlags(Qt.FramelessWindowHint | Qt.WindowDoesNotAcceptFocus | Qt.WindowStaysOnTopHint)
# Hide mouse cursor
self.app_widget.setCursor(Qt.BlankCursor)
self.app_widget.setGeometry(0, 0, self.screen_width, self.screen_height) # Set the size of Qlabel to size of the screen
self.app_widget.setWindowTitle('myImageDisplayApp')
self.app_widget.setAlignment(Qt.AlignLeft | Qt.AlignTop) #https://doc.qt.io/qt-5/qt.html#AlignmentFlag-enum
self.app_widget.setPixmap(self.pixmap)
self.app_widget.show()
# Set the screen on which widget is on
self.app_widget.windowHandle().setScreen(self.screen)
# Make full screen
self.app_widget.showFullScreen()
def updateImage(self, pattern_file=None):
print('Pattern file given: ', pattern_file)
self.app_widget.clear() # Clear all existing content of the QLabel
self.pixmap = QPixmap(pattern_file) # Update pixmap with desired image
self.app_widget.setPixmap(self.pixmap) # Show desired image on Qlabel
if __name__ == "__main__":
main()
I would also like to thank #ekhumoro for pointing me to QWidget attributes/flags.

You should not run the GUI in other than the main thread since Qt does not guarantee that it works correctly as indicated by the docs. Instead of executing the GUI in another thread, you must execute the other heavy tasks in another thread.
You have to change your approach to classical sequential logic but you must use event-oriented programming where actions are taken before an event, in the case of Qt through signals.
Considering the above, the solution is:
import sys
import time
from PyQt5.QtCore import pyqtSignal, pyqtSlot, QObject, Qt, QThread, QTimer
from PyQt5.QtGui import QColor, QPixmap
from PyQt5.QtWidgets import QApplication, QLabel, QWidget
class TaskManager(QObject):
task3Finished = pyqtSignal()
task4Finished = pyqtSignal()
#pyqtSlot()
def task3(self):
print("Step 3")
print(" Continue some logic while QT running in background")
time.sleep(2)
self.task3Finished.emit()
#pyqtSlot()
def task4(self):
print("Step 4")
print(" Update the displayed image in the QT app running in background")
time.sleep(2)
self.task4Finished.emit()
class qtAppWidget(QWidget):
def __init__(self, parent=None):
super().__init__(parent)
self.setupGUI()
def setupGUI(self):
self.app = QApplication.instance()
# Get avaliable screens/monitors
# https://doc.qt.io/qt-5/qscreen.html
# Get info on selected screen
self.selected_screen = 0 # Select the desired monitor/screen
self.screens_available = self.app.screens()
self.screen = self.screens_available[self.selected_screen]
self.screen_width = self.screen.size().width()
self.screen_height = self.screen.size().height()
# Create a black image for init
self.pixmap = QPixmap(self.screen_width, self.screen_height)
self.pixmap.fill(QColor("black"))
# Create QLabel object
self.app_widget = QLabel()
# Varioius flags that can be applied to make displayed window frameless, fullscreen, etc...
# https://doc.qt.io/qt-5/qt.html#WindowType-enum
# https://doc.qt.io/qt-5/qt.html#WidgetAttribute-enum
self.app_widget.setWindowFlags(
Qt.FramelessWindowHint
| Qt.WindowDoesNotAcceptFocus
| Qt.WindowStaysOnTopHint
)
# Hide mouse cursor
self.app_widget.setCursor(Qt.BlankCursor)
self.app_widget.setGeometry(
0, 0, self.screen_width, self.screen_height
) # Set the size of Qlabel to size of the screen
self.app_widget.setWindowTitle("myImageDisplayApp")
self.app_widget.setAlignment(
Qt.AlignLeft | Qt.AlignTop
) # https://doc.qt.io/qt-5/qt.html#AlignmentFlag-enum
self.app_widget.setPixmap(self.pixmap)
self.app_widget.show()
# Set the screen on which widget is on
self.app_widget.windowHandle().setScreen(self.screen)
# Make full screen
self.app_widget.show()
#pyqtSlot()
def on_task3_finished(self):
pixmap = QPixmap("qt_test_static_1.png")
self.app_widget.setPixmap(pixmap)
#pyqtSlot()
def on_task4_finished(self):
pixmap = QPixmap("qt_test_static_2.png")
self.app_widget.setPixmap(pixmap)
# quit application after to 2 secons
QTimer.singleShot(2 * 1000, QApplication.quit)
def main(args):
print("Step 1")
print(" Some logic here without QT")
print("Step 2")
print(" Launch QT app to run")
app = QApplication(args)
myapp = qtAppWidget()
thread = QThread()
thread.start()
manager = TaskManager()
# move the QObject to the other thread
manager.moveToThread(thread)
manager.task3Finished.connect(myapp.on_task3_finished)
manager.task3Finished.connect(manager.task4)
manager.task4Finished.connect(myapp.on_task4_finished)
# start task
QTimer.singleShot(0, manager.task3)
ret = app.exec_()
thread.quit()
thread.wait()
del thread, app
return ret
if __name__ == "__main__":
sys.exit(main(sys.argv))

Saving Mipmap files

So, I am almost done with building my program that creates mipmaps. It will successfully upload an image of your choosing, and create mipmaps of that image, but now the last part is where I am stuck.
I now want for the the user to be able to save his or her mipmaps, but I am not sure how. I want them to be able to save it anywhere they want, and I have a feeling it will require a dialoq box, but I only know how to implement dialog boxes when opening items, not saving them.
Here is my code so far:
from __future__ import division
from PyQt4 import QtCore, QtGui, QtOpenGL
from PyQt4.QtGui import * #Used to import QPixmap. DO NOT REMOVE.
from PyQt4.QtCore import * #Used to import Qt.KeepAspectRation. DO NOT REMOVE.
import sys, os
import mmCreator
class MyApp(QtGui.QMainWindow, mmCreator.Ui_MainWindow):
def __init__(self, parent=None):
super(MyApp, self).__init__(parent)
self.setupUi(self)
self.btnSelect.clicked.connect(self.select_image)
self.btnConvert.clicked.connect(self.mipmap)
self.btnDownload.clicked.connect(self.download)
def select_image(self):
self.origImage.setAlignment(QtCore.Qt.AlignCenter)
self.origImage.clear()
global image
image = QtGui.QFileDialog.getOpenFileName(self,
"Select Image",
"",
"Image File (*.jpg *.png *.gif)")
global pixmap
pixmap = QPixmap(image)
scaledPixmap = pixmap.scaled(self.origImage.size(), Qt.KeepAspectRatio)
self.origImage.setPixmap(scaledPixmap)
self.origImage.show()
def mipmap(self):
self.mipMap.setAlignment(QtCore.Qt.AlignCenter)
#Create scaled versions of the source image.
pixmap = QPixmap(image)
global mipmaps
mipmaps = []
#Version 1 goes up to 1/16 of original size.
mipmaps.append(pixmap.scaledToWidth(pixmap.width() / 2))
mipmaps.append(pixmap.scaledToWidth(pixmap.width() / 4))
mipmaps.append(pixmap.scaledToWidth(pixmap.width() / 8))
mipmaps.append(pixmap.scaledToWidth(pixmap.width() / 16))
#Show the first mipmapped version of the image, at 75% label size.
scaledMipMap = mipmaps[0].scaled(self.mipMap.size() * (3/4), Qt.KeepAspectRatio)
self.mipMap.setPixmap(scaledMipMap)
self.mipMap.show()
def download():
mipmaps.save('/path/to/file.png', 'PNG')
def main():
app = QtGui.QApplication(sys.argv)
form = MyApp()
form.show()
app.exec_()
if __name__ == '__main__':
main()

To open/save any documents, there are two steps:
Get the path as a string, for example "/home/Documents/myImage.png". One way to get the path is to ask the user in a dialog.
Qt provides methods to do this, one being getSaveFileName(). From the doc:
This is a convenience static function that will return a file name
selected by the user. The file does not have to exist.
This methods returns a file name: it does not save anything.
Open or save the document, using the path.
To load the image, you used pixmap = QPixmap(imagePath)
To save it, you can use pixmap.save(imagePath) (doc)

Update LCD Number countdown

I'm very new to Python and I have made a very simple countdown timer. The GUI was created in Qt Designer. There is a spin box for input of seconds, a start button and an LCD number counter. The counter counts down fine using the code below:
def start_btn_clicked(self):
x = self.Minute_spinBox.value()
for i in xrange(x,0,-1):
time.sleep(1)
print (i)
So that I could see what was happening as I played around with it, I added the print instruction so that it shows the countdown in the Python console as it runs. I then thought I could maybe quite easily have the LCD number display the countdown with something like:
self.lcdNumber.display(i)("%SS")
But no matter what I try, I cant get it to show. With the line above, I get the first number displayed, but then I get an error saying:
self.lcdNumber.display(i)("%SS")
TypeError: 'NoneType' object is not callable
I have tried so many variations that I no longer know where I started and here was me thinking it would be simple. I'd love to know why I cant get it to display the countdown.

Just adding one line of code to my original code will allow the lcdNumber to display the count...
def start_btn_clicked(self):
x = self.Minute_spinBox.value()
for i in xrange(x,0,-1):
time.sleep(1)
app.processEvents() # just this one line allows display of 'i'
self.lcdNumber.display(i)`
And works perfectly

The display function returns None, so doing None("%SS") obviously isn't allowed.
self.lcdNumber.display(i) is enough to show the countdown!
To let Qt paint the widgets while looping run the countdown from another thread. See an example.
import time
from threading import Thread
from PyQt4.QtGui import QApplication, QMainWindow, QLCDNumber
class Window(QMainWindow):
def __init__(self):
QMainWindow.__init__(self)
self.lcdnumber = QLCDNumber(self)
self.resize(400, 400)
t = Thread(target=self._countdown)
t.start()
def _countdown(self):
x = 10
for i in xrange(x,0,-1):
time.sleep(1)
self.lcdnumber.display(i)
if __name__ == "__main__":
app = QApplication([])
window = Window()
window.show()
app.exec_()

The for loop is blocking the GUI.
The slot connected to the button's clicked signal is processed synchronously. This means the event-loop must wait for the slot to return before it can process any more events (including the paint events needed for updating the GUI).
So you need to find a way to process these events whilst the for loop is running. There are various ways of doing this, such as using a QTimer or a QThread. But the simplest way of fixing your particular example would be to use QCoreApplication.processEvents.
Here's an example that shows how to do that:
import sys, time
from PyQt4 import QtCore, QtGui
class Window(QtGui.QWidget):
def __init__(self):
super(Window, self).__init__()
self.spinbox = QtGui.QSpinBox(self)
self.spinbox.setValue(5)
self.lcdnumber = QtGui.QLCDNumber(self)
self.button = QtGui.QPushButton('Start', self)
self.button.clicked.connect(self.handleButton)
layout = QtGui.QVBoxLayout(self)
layout.addWidget(self.spinbox)
layout.addWidget(self.lcdnumber)
layout.addWidget(self.button)
def handleButton(self):
for tick in range(self.spinbox.value(), -1, -1):
self.lcdnumber.display(tick)
self.button.setEnabled(not tick)
# continually process events for one second
start = time.time()
while time.time() - start < 1:
QtGui.qApp.processEvents()
time.sleep(0.02)
if __name__ == '__main__':
app = QtGui.QApplication(sys.argv)
window = Window()
window.setGeometry(500, 300, 300, 200)
window.show()
sys.exit(app.exec_())