Aspect Ratio du Moniteur

Bonjour à tous,

Je voulais savoir s'il existe une fonction permettant d'obtenir l'aspect ratio du moniteur (par exemple 4:3 , 16:9) et non pas celui de la résolution dans laquelle il se trouve. Je veux donc dire celui du constructeur de l'écran et qui n'est donc évidemment pas modifiable.

Merci à tous

Ca dépend de la plateforme...

Sous windows cherche les fonctions avec HMONITOR... y a tout un tas de fonctions qui peuvent t'interesser.

Salut,
Sous windows, on doit pouvoir s'en sortir avec GetDeviceCaps et HORZSIZE/VERTSIZE il me semble ?

Bonjour,

Non, GetDeviceCaps ne renvoie pas la taille physique de l'écran, elle renvoie la résolution active.
Par contre, j'ai trouvé une piste intéressante avec la base de données EDID qui renvoie les paramètres de l'écran et notamment la taille maximale de l'écran en cm.
Le progiciel MonitorView renvoie très bien cette info.
A priori, on peut l'obtenir aussi avec l'interruption 10h fonction 4f15h bl = 01h. Les paramètres sont pointés par es:di offset 15h et 16h.
Reste donc à appeler cette interruption en C++ mais je coince bêtement sur la déclaration de REGS regs qui n'est pas comprise par VC++. Quel header dois je mettre pour que cela compile ?

Merci

Citation:

Envoyé par MSDN

GetDeviceCaps :
HORZSIZE Width, in millimeters, of the physical screen.
VERTSIZE Height, in millimeters, of the physical screen.

J'ai testé cela ne fonctionne pas car dépend de la résolution choisie ...

Effectivement. Désolé, je me suis laissé abuser par la description que j'ai mal comprise.

ce n'est pas grave.
EDID est la bonne piste : renvoie la taille PHYSIQUE de l'écran en cm.
Comment dois je procéder pour REGS ?

Bonjour,

Voici le code pour lire la clef de registre sur le moniteur dans l'EDID :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
 
/**********************************************************************
* Get_MonitorDevice                                                   *
* gets monitor device                                                 *
**********************************************************************/
 
BOOL CTurn_For_You::Get_MonitorDevice( TCHAR* adapterName, DISPLAY_DEVICE &ddMon )
{            
        DWORD devMon = 0; 
        while (EnumDisplayDevices(adapterName, devMon, &ddMon, 0))                
        { 
                if (ddMon.StateFlags & DISPLAY_DEVICE_ACTIVE &&    
                        ddMon.StateFlags & DISPLAY_DEVICE_ATTACHED) // for ATI, Windows XP 
                        break; 
                devMon++; 
        }  
                if (!*ddMon.DeviceString)
                {       
                        EnumDisplayDevices(adapterName, 0, &ddMon, 0); 
                        if (!*ddMon.DeviceString)  
                                _tcscpy_s(ddMon.DeviceString, _T("Default Monitor"));  
                }   
                return ddMon.DeviceID != '\0';  
}
 
/**********************************************************************
* Get_MonitorDevice                                                   *
* gets monitor device                                                 *
**********************************************************************/
 
BOOL CTurn_For_You::Get_MonitorSizeFromEDID(TCHAR* adapterName, DWORD& Width, DWORD& Height)
{
                DISPLAY_DEVICE ddMon; 
                ZeroMemory(&ddMon, sizeof(ddMon));
                ddMon.cb = sizeof(ddMon);                //read edid 
                bool result = false;
                Width = 0;
                Height = 0;
                if (Get_MonitorDevice(adapterName, ddMon)) 
                {
                        TCHAR model[8];
                        TCHAR* s = _tcschr(ddMon.DeviceID, '\\') + 1;
                        size_t len = _tcschr(s, '\\') - s;
                        if (len >= _countof(model)) 
                                len = _countof(model) - 1;    
                        _tcsncpy_s(model, s, len);
                        TCHAR *path = _tcschr(ddMon.DeviceID, '\\') + 1;
                        TCHAR str[MAX_PATH] = _T("SYSTEM\\CurrentControlSet\\Enum\\DISPLAY\\");
                        _tcsncat_s(str, path, _tcschr(path, '\\')-path);
                        path = _tcschr(path, '\\') + 1;
                        HKEY hKey;
                        if(RegOpenKeyEx(HKEY_LOCAL_MACHINE, str, 0, KEY_READ, &hKey) == ERROR_SUCCESS)
                        {
                                DWORD i = 0;
                                DWORD size = MAX_PATH;
                                FILETIME ft;
                                while(RegEnumKeyEx(hKey, i, str, &size, NULL, NULL, NULL, &ft) == ERROR_SUCCESS)
                                {
                                        HKEY hKey2;
                                        if(RegOpenKeyEx(hKey, str, 0, KEY_READ, &hKey2) == ERROR_SUCCESS)
                                        {
                                                size = MAX_PATH;
                                                if(RegQueryValueEx(hKey2, _T("Driver"), NULL, NULL, (LPBYTE)&str, &size) == ERROR_SUCCESS)
                                                {
                                                        if (_tcscmp(str, path) == 0)
                                                        {
                                                              HKEY hKey3;
                                                              if(RegOpenKeyEx(hKey2, _T("Device Parameters"), 0, KEY_READ, &hKey3) == ERROR_SUCCESS)
                                                              {
                                                                      BYTE EDID[256]; 
                                                                      size = 256;
                                                                      if(RegQueryValueEx(hKey3, _T("EDID"), NULL, NULL, (LPBYTE)&EDID, &size) == ERROR_SUCCESS)
                                                                      {
                                                                              DWORD p = 8; 
                                                                              TCHAR model2[9];
                                                                              char byte1 = EDID[p];
                                                                              char byte2 = EDID[p+1]; 
                                                                              model2[0]=((byte1 & 0x7C) >> 2) + 64;
                                                                              model2[1]=((byte1 & 3) << 3) + ((byte2 & 0xE0) >> 5) + 64;
                                                                              model2[2]=(byte2 & 0x1F) + 64;
                                                                              _stprintf(model2 + 3, _T("%X%X%X%X"), (EDID[p+3] & 0xf0) >> 4, EDID[p+3] & 0xf, (EDID[p+2] & 0xf0) >> 4, EDID[p+2] & 0x0f);
                                                                              if (_tcscmp(model, model2) == 0)
                                                                              {
                                                                                      Width = EDID[22];
                                                                                      Height = EDID[21];
                                                                                      result = true;
                                                                              }
                                                                              else
                                                                              {  
                                                                              // EDID incorrect
                                                                              }
                                                                      }
                                                                      RegCloseKey(hKey3);
                                                              } 
                                                        }
                                                }
                                                RegCloseKey(hKey2);
                                        }
                                        i++;
                                }
                                RegCloseKey(hKey);
                        }
                }
                 return result;
}

Néanmoins, il y a sur deux machines différentes, l'erreur 2 (le fichier spécifié est introuvable) qui subsiste au niveau de l'appel de RegOpenKeyEx.
Si quelqu'un a une idée ...

La taille de l'écran est renvoyée dans Width et Height ...

Merci à tous,