Ermitteln der verfügbaren Bildschirmauflösungen in Qt/C++

Question

unter Windows und anderen Desktop-Betriebssystemen ist immer ein Kombinationsfeld in den Anzeigeeinstellungen, das alle verfügbaren Bildschirmauflösungen anzeigt.

Ich brauche diese Art von Combo-Box in Qt oder C++ und ich bin fest.

fand ich einen C# Ansatz hier: How to list available video modes using C#?

fand ich einen C++ Ansatz: How to Detect Maximize event on multi-monitor system

MSDN sagt in EnumDisplaySettingsEx function Doku, dass alle Display-Auflösungen von Iterierte über das Argument iModeNum erhalten werden können:

Grafikmodusindizes beginnen bei Null. Um Informationen für alle Grafikmodi eines Anzeigegeräts abzurufen, führen Sie eine Reihe von Aufrufen für EnumDisplaySettingsEx wie folgt aus: Setzen Sie für den ersten Aufruf iModeNum auf Null, und erhöhen Sie für jeden nachfolgenden Aufruf iModeNum um eins. Fahren Sie mit dem Aufruf der Funktion fort, bis der Rückgabewert Null ist.

Ich habe den C++ Ansatz geändert mein Ziel in Windows zu erhalten:

#include <QCoreApplication> 

#include <windows.h> 
#include <stdio.h> 

#define DEFAULT_DISPLAY_WIDTH 0 
#define DEFAULT_DISPLAY_HEIGHT 0 
#define DEFAULT_DISPLAY_FREQUENCY 60 
#define DEFAULT_DISPLAY_SOURCE 0 

struct DisplayResolution 
{ 
    DisplayResolution(int _width = DEFAULT_DISPLAY_WIDTH, 
         int _height = DEFAULT_DISPLAY_HEIGHT, 
         int _frequency = DEFAULT_DISPLAY_FREQUENCY, 
         int _defaultSource = DEFAULT_DISPLAY_SOURCE) 
    { 
     width = _width; 
     height = _height; 
     frequency = _frequency; 
     defaultSource = _defaultSource; 
    } 

    int width; 
    int height; 
    int frequency; 
    int defaultSource; 

}; 

typedef std::vector<DisplayResolution>::iterator DisplayResolutionIterator; 

std::vector<DisplayResolution> getAvailableDisplayResolutions() 
{ 
    DISPLAY_DEVICE disp; 
    DISPLAY_DEVICE adapter; 
    DEVMODE mode; 
    std::vector<DisplayResolution> displayResolutions; 
    int i = 0, j = 0, display_count = 0, k = 0; 

    // Initialize win32 structs. 
    memset(&disp, 0, sizeof(DISPLAY_DEVICE)); 
    disp.cb = sizeof(DISPLAY_DEVICE); 
    memset(&adapter, 0, sizeof(DISPLAY_DEVICE)); 
    adapter.cb = sizeof(DISPLAY_DEVICE); 
    memset(&mode, 0, sizeof(DEVMODE)); 
    mode.dmSize = sizeof(DEVMODE); 

    //memset(the_displays, 0, sizeof(the_displays)); 

    // adapter loop: 
    while(EnumDisplayDevices(NULL, i, &adapter, 0)) 
    { // multiple displays on single adapter loop: 
     j = 0; 
     qDebug() << (TCHAR*)&adapter.DeviceName; 
     while(EnumDisplayDevices((TCHAR*)&adapter.DeviceName, j, &disp, 0)) 
     { 
      // The device must be active, attached to desktop and not a mirroring device. 
      if((disp.StateFlags & DISPLAY_DEVICE_ACTIVE) 
       && (disp.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP) 
       && !(disp.StateFlags & DISPLAY_DEVICE_MIRRORING_DRIVER)) 
      { 
       // read display settings. 
       k = 0; 
       while(EnumDisplaySettingsEx((TCHAR*)&adapter.DeviceName, k, &mode, 0)) 
       { 
        displayResolutions.push_back(DisplayResolution(mode.dmPelsWidth, 
                    mode.dmPelsHeight, 
                    mode.dmDisplayFrequency, 
                    mode.dmDefaultSource)); 
        // Reset 
        memset(&mode, 0, sizeof(DEVMODE)); 
        mode.dmSize = sizeof(DEVMODE); 
        ++display_count; 
        ++k; 
       } 

      } 
      // Reset 
      memset(&disp, 0, sizeof(DISPLAY_DEVICE)); 
      disp.cb = sizeof(DISPLAY_DEVICE); 
      ++j; 
     } 
     // Reset 
     memset(&adapter, 0, sizeof(DISPLAY_DEVICE)); 
     adapter.cb = sizeof(DISPLAY_DEVICE); 
     ++i; 
    } 
    return displayResolutions; 
} 

int main(int argc, char *argv[]) 
{ 
    QCoreApplication a(argc, argv); 

    std::vector<DisplayResolution> displayResolutions = getAvailableDisplayResolutions(); 

    DisplayResolutionIterator it = displayResolutions.begin(); 
    DisplayResolutionIterator itEnd = displayResolutions.end(); 
    for(it; it != itEnd; ++it) 
    { 
     printf("Resolution: "); 
     printf("%i x %i", (*it).width, (*it).height); 
     printf(" (%iHz)", (*it).frequency); 
     printf(" @Source:%i", (*it).defaultSource); 
     printf("\n"); 
    } 

    return a.exec(); 
} 

Hoffentlich hilft es Menschen in Windows zu lesen, aber Unix?

Ich kenne eine Methode in Qt, aber dies wird nur die aktuelle Bildschirmauflösung über QDesktopWidget::availableGeometry sammeln.

Hat Qt eine Methode, um alle verfügbaren Bildschirmauflösungen zu erhalten?

Mit freundlichen Grüßen,
Pixtar

Answer 1

Qt bietet keine APIs mit solchen Informationen. Sie können die aktuelle Auflösung eines gegebenen Bildschirms über QScreen:geometry() erhalten. Aber es gibt keine Möglichkeit, eine Liste der verfügbaren Auflösungen zu erhalten oder sie zu wechseln.

Sie müssen nach plattformspezifischen Fragen dazu suchen und sie fragen, ob sie nicht existieren. Eine Frage sollte eine Plattform abdecken.