Comment déterminer un écran actif (moniteur) de mon Application (fenêtre) en utilisant python PyQt5 ?

Une solution que j'ai trouvée consiste à utiliser un QApplication() temporaire :

import sys
from PyQt5 import QtWidgets, QtCore, QtGui

# fire up a temporary QApplication
def get_resolution():

    app = QtWidgets.QApplication(sys.argv)

    print(app.primaryScreen())

    d = app.desktop()

    print(d.screenGeometry())
    print(d.availableGeometry())
    print(d.screenCount())    

    g = d.screenGeometry()
    return (g.width(), g.height())

x, y = get_resolution()

if x > 1920 and y > 1080:
  QtWidgets.QApplication.setAttribute(QtCore.Qt.AA_EnableHighDpiScaling, True)
  QtWidgets.QApplication.setAttribute(QtCore.Qt.AA_UseHighDpiPixmaps, True)
else:
  QtWidgets.QApplication.setAttribute(QtCore.Qt.AA_EnableHighDpiScaling, False)
  QtWidgets.QApplication.setAttribute(QtCore.Qt.AA_UseHighDpiPixmaps, False)

# Now your code ...

Cette fonction détectera tous les écrans attachés :

# fire up a temporary QApplication
def get_resolution_multiple_screens():

    app = QtGui.QGuiApplication(sys.argv)
    #QtWidgets.QtGui
    all_screens = app.screens()

    for s in all_screens:

        print()
        print(s.name())
        print(s.availableGeometry())
        print(s.availableGeometry().width())
        print(s.availableGeometry().height())
        print(s.size())
        print(s.size().width())
        print(s.size().height())

    print()
    print('primary:', app.primaryScreen())
    print('primary:', app.primaryScreen().availableGeometry().width())
    print('primary:', app.primaryScreen().availableGeometry().height())

    # now choose one

Vous pouvez utiliser les conseils ici et ici pour obtenir l'écran où l'application est en cours d'exécution.

Mais je pense que primaryScreen devrait également renvoyer ceci :

primaryScreen :QScreen* const

Cette propriété contient l'écran principal (ou par défaut) de l'application.

Ce sera l'écran où QWindows sera initialement affiché, sauf indication contraire.

(https://doc.qt.io/qt-5/qguiapplication.html#primaryScreen-prop)

Eh bien, après avoir créé la MainWindow, vous pouvez simplement appeler QMainWindow.screen(). Cela renvoie l'écran actuel sur lequel se trouve MainWindow. Cela vous permettrait au moins de vérifier la résolution de l'écran au démarrage de votre application. À l'heure actuelle, il n'existe pas de screenChangeEvent. Cependant, je suis sûr que vous pouvez en créer un en sous-classant MainWindow et en surchargeant le QMainWindow.moveEvent

Par exemple :

    class MainWindow(QtWidgets.QMainWindow):
        screenChanged = QtCore.pyqtSignal(QtGui.QScreen, QtGui.QScreen)

        def moveEvent(self, event):
            oldScreen = QtWidgets.QApplication.screenAt(event.oldPos())
            newScreen = QtWidgets.QApplication.screenAt(event.pos())

            if not oldScreen == newScreen:
                self.screenChanged.emit(oldScreen, newScreen)

            return super().moveEvent(event)

Ceci vérifie si l'écran a changé. Si c'est le cas, il émet un signal. Il ne vous reste plus qu'à connecter ce signal à une fonction qui définit vos attributs dpi. L'événement vous donne accès à l'ancien et au nouvel écran.

Avertissement :

L'un des écrans peut être None au début de votre application car il n'y a pas de oldScreen lorsque vous démarrez votre application pour la première fois. Veuillez donc vérifier ceci.

Bien que je ne puisse pas obtenir la solution directe, je suis capable de développer une méthode pour obtenir ce que je cherchais. Avec l'aide de quelques liens et post précédent, je suis en mesure d'atteindre. avec ce post, j'ai eu une idée du suivi de l'événement de la souris.

J'ai développé une méthode pour suivre tous les moniteurs et les positions de regard respectives. si le nom de ma variable n'est pas approprié, je suis heureux d'accepter les modifications

def get_screen_resolution():
  app = QApplication(sys.argv)
  screen_count = QGuiApplication.screens()
  resolutions_in_x = []

  for index, screen_names in enumerate(screen_count):
    resolution = screen_count[index].size()
    height = resolution.height()
    width = resolution.width()
    resolutions_in_x.append(width)

  low_resolution_monitors = {}
  high_resolution_monitors = {}

  for i, wid_res in enumerate(resolutions_in_x):
    if wid_res > 1920:
      high_resolution_monitors.update({i: wid_res})
    else:
      low_resolution_monitors.update({'L': wid_res})    
  temp_value = 0
  high_res_monitors_x_position = []
  low_res_monitors_x_position = []
  for i in range(len(screen_count)):
    temp_value = temp_value+resolutions_in_x[i]
      if resolutions_in_x[i] in high_resolution_monitors.values():
        high_res_monitors_x_position.append(temp_value-resolutions_in_x[i])
      else:
        low_res_monitors_x_position.append(temp_value-resolutions_in_x[i])

  total_width_res = []
  pixel_value = 0
  first_pixel = 0
  for i, wid_value in enumerate(resolutions_in_x):
    pixel_value = pixel_value + wid_value
    total_width_res.append(tuple((first_pixel, pixel_value-1)))
    first_pixel = pixel_value

  return high_res_monitors_x_position, low_res_monitors_x_position, total_width_res


def moveEvent(self, event):

screen_pos = self.pos()
screen_dimensions = [screen_pos.x(),screen_pos.y()]
super(MainWindow, self).moveEvent(event)

Window_starting_pt = screen_pos.x()
for i, value in enumerate(self.total_width_res):
  if value[0]<=Window_starting_pt+30 <=value[1] or value[0]<=Window_starting_pt-30 <=value[1]: #taking 30pixels as tolerance since widgets are staring at some negative pixel values
    if value[0] in self.high_res_monitors_x_position:
      QtWidgets.QApplication.setAttribute(QtCore.Qt.AA_EnableHighDpiScaling, True)
      QtWidgets.QApplication.setAttribute(QtCore.Qt.AA_UseHighDpiPixmaps, True)
    else:
      QtWidgets.QApplication.setAttribute(QtCore.Qt.AA_EnableHighDpiScaling, False)
      QtWidgets.QApplication.setAttribute(QtCore.Qt.AA_UseHighDpiPixmaps, False)

Avec ces deux fonctions, je suis capable de suivre la position de mon application (fenêtre) et également de suivre à quel moment elle est déplacée entre les fenêtres