Calcul de la résolution de l'écran sur Windows 10

**cincap** · 28/09/2018, 08h51

Bonjour à toutes et à tous,

Comme déjà dit, avec un fichier *.bat en une seule ligne je retrouve la résolution réelle de l'écran soit 1920 x 1080 et le nombre de couleurs.

Pensez vous qu'en ajoutant Wmi dans le uses on pourrait convertir ce code pour l'exploiter en Delphi.

J'ai essayé mais en vain.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
 
FOR /F "skip=2 delims=" %%a IN ('wmic path Win32_VideoController get VideoModeDescription^,CurrentHorizontalResolution^,CurrentVerticalResolution /format:Value') do set %%a >nul 
echo Width =^> %CurrentHorizontalResolution%
echo Height =^> %CurrentVerticalResolution%

Merci de l'aide éventuelle.

J'ai testé en mode console avec la suggestion de SergioMaster et le résultat est étonnant 1024 x 768 au lieu de 1920 x 1080 !

@+,

cincap

**SergioMaster** · 28/09/2018, 09h26

Bonjour
as-tu remarqué que tu ne faisais pas la même interrogation que dans mon code ?
dans ton fichier de commande tu utilises W32_VideoController alors je proposais une interrogation de Win32_DisplayConfiguration ?
En fait dans les WMI il semble qu'il y ait au moins trois interrogations possibles ces deux dernières mais aussi win32_DisplayControllerConfiguration

je ne suis donc pas sur que ton utilisation de w32_videocontroller soit donc la meilleure source d'information

Pour ce qui est du code proposé, il n'est pas de moi comme l'indique clairement les commentaires de début, mais d'une génération de code fait par l'outil WMI Delphi Code Creator que j'utilise beaucoup (en particulier l'option WMI Finder) dès qu'il s'agit de chercher des informations Microsoft.
De mon point de vue cela prouve le désordre du système d'information des registres Microsoft (et dire qu'on nous demande de faire confiance à MSSQL

)

Évidemment, le code proposé est un programme console (c'est le dommage du truc) et non une fonction utilisable directement dans une autre programme.
En fait j'utilise rarement le code proposé, les requêtes WMI à l'intérieur de l'outil me suffisent.
Je sais que j'ai intégré dans plusieurs de mes programmes des appels aux WMI, il faut juste que j'en retrouve un pour pouvoir te proposer un code, patience.

**cincap** · 28/09/2018, 09h56

@ SergioMaster, merci pour ton info :

je ne suis donc pas sur que ton utilisation de w32_videocontroller soit donc la meilleure source d'information

C'est pourtant le seul code qui me donne l'exactitude de la résolution (1920 x 1080) malgré l'échelle de 120% (photo en attache)

Ta suggestion :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
FSWbemLocator := CreateOleObject('WbemScripting.SWbemLocator');
  FWMIService   := FSWbemLocator.ConnectServer(WbemComputer, 'root\CIMV2', WbemUser, WbemPassword);
  FWbemObjectSet:= FWMIService.ExecQuery('SELECT * FROM Win32_DisplayConfiguration','WQL',wbemFlagForwardOnly);
  oEnum         := IUnknown(FWbemObjectSet._NewEnum) as IEnumVariant;
  while oEnum.Next(1, FWbemObject, iValue) = 0 do
  begin
    Writeln(Format('PelsHeight    %d',[Integer(FWbemObject.PelsHeight)]));// Uint32
    Writeln(Format('PelsWidth     %d',[Integer(FWbemObject.PelsWidth)]));// Uint32

Elle m'indique 1024 x 768 (photo en attache)

@+,

cincap

**SergioMaster** · 28/09/2018, 10h14

En cherchant dans la doc Microsoft :

The Win32_DisplayControllerConfiguration WMI class represents the video adapter configuration information of a computer system running Windows.
This class is obsolete. In place of this class, you should use the properties in the Win32_VideoController, Win32_DesktopMonitor, and CIM_VideoControllerResolution classes.

Donc, quid d'un essai sur Win32_DesktopMonitor "propriétés" ScreenHeight et ScreenWidth

**cincap** · 28/09/2018, 10h28

@ SergioMaster, merci de ta participation soutenue, je pense que seul "Win32_VideoController" doit être utilisé car j'ai retrouver une source qui liste toutes les requêtes et seule celle la m'indique la résolution exacte.

Voir photo.

@+,

cincap

**cincap** · 01/10/2018, 10h48

Bonjour à toutes et à tous,

Avec la procédure Wmi et le type "Videocontroller", j'affiche la liste de toutes les caractéristiques dans un Tmemo.

J'ai donc adapté un code pour déterminer la ligne ou se trouve les propriétés de mon écran et récupérer les 4 derniers caractères de cette ligne dans un Tedit.

Il y a certainement plus simple et plus rapide mais comme je ne maitrise pas l'utilisation de Wmi, cela me convient pour le moment.

A toutes fins voici ma solution :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
 
procedure TFResolution.BResolutionClick(Sender: TObject);
var
  Server: string;
  Enum: IEnumVARIANT;
  varArr: OleVariant;
  lNumElements: ULong;
  AName: array[0..255] of Char;
  ASize: DWORD;
begin
  if (ParamCount = 0) then
  begin
    Server := '';
    ASize  := SizeOf(AName) - 1;
    if GetComputerName(@AName, ASize) then Server := AName;
  end
  else
  begin
    Server := ParamStr(1);
  end;
  try
    MVideoController.Lines.BeginUpdate;
    Enum := CoSWbemLocator.Create.ConnectServer(Server, 'root\cimv2', '',
      '', '', '', 0, nil).ExecQuery('Select * from Win32_videocontroller', 'WQL',
      wbemFlagBidirectional, nil)._NewEnum as IEnumVariant;
    while (Succeeded(ADsEnumerateNext(Enum, 1, varArr, lNumElements))) and
      (lNumElements > 0) do
    begin
      DumpWMI_Process(IUnknown(varArr) as SWBemObject);
    end;
  finally
    MVideoController.Lines.EndUpdate;
 
    //Ligne 73 et position 37 les 4 derniers chiffres
    EdWidth.Text := Copy(MVideoController.Lines[73], Pos(' ',MVideoController.Lines[73]) +37, Length(MVideoController.Lines[73])); //Width CurrentHorizontalResolution
 
    //Ligne 79 et position 35 les 4 derniers chiffres
    EdHeight.Text := Copy(MVideoController.Lines[79], Pos(' ',MVideoController.Lines[79]) +35, Length(MVideoController.Lines[79])); //Height CurrentVerticalResolution
 
  end;
end;

Je ferme ce topic.

Merci à tous,

@+,

cincap

**SergioMaster** · 01/10/2018, 11h36

Bonjour,

c'est loin d'être top

bon, déjà sais tu que WSQL est un peu comme du SQL donc tu pourrais modifier ta requête en

Code SQL :

Sélectionner tout - Visualiser dans une fenêtre à part

Select PelsHeight,PelsWidth from Win32_videocontroller

**cincap** · 01/10/2018, 12h45

@ SergioMaster, merci de ta suggestion, j'ai testé tel quel mais erreur à l'exécution.

c'est loin d'être top

Je l'avais noté dans mon commentaire !

Il faut donc utilisé avec "Win32_videocontroller":

Select CurrentHorizontalResolution, CurrentVerticalResolution from Win32_videocontroller

Ensuite récupérer de la liste uniquement le 1920 x 1080.

@+,

cincap

**SergioMaster** · 01/10/2018, 13h54

désolé j'étais resté sur le même nom de colonnes que displayconfiguration.
Reste que je vais tenter d'en faire quelque chose de plus propre que cette extraction de chaine si j'ai quelques minutes cet après-midi

**cincap** · 01/10/2018, 14h03

@ SergioMaster,

désolé j'étais resté sur le même nom de colonnes que displayconfiguration.

Pas de problème on a déjà bien avancé.

En ce qui concerne voici le code complet de mon test (plus que 6 lignes à parcourir avec ta suggestion !) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
implementation
 
{$R *.dfm}
 
uses
  ActiveX, WbemScripting_TLB;
 
function ADsEnumerateNext(pEnumVariant: IEnumVARIANT; cElements: ULONG;
  var pvar: OleVARIANT; var pcElementsFetched: ULONG): HRESULT; safecall; external 'activeds.dll';
 
procedure DumpWMI_Process(Process: SWBemObject);
var
  Enum: IEnumVARIANT;
  varArr: OleVariant;
  lNumElements: ULong;
  SProp: ISWbemProperty;
  Prop: OleVariant;
  PropName: string;
  PropType: string;
  PropValue: string;
begin
  FResolution.MVideoController.Lines.Add('+ WMI Path: ' + Process.Path_.Path);
  Enum := Process.Properties_._NewEnum as IEnumVariant;
  while (Succeeded(ADsEnumerateNext(Enum, 1, VarArr, lNumElements))) and
    (lNumElements > 0) do
  begin
    if Succeeded(IDispatch(varArr).QueryInterface(SWBemProperty, SProp)) and
      Assigned(SProp) then
    begin
      try
        PropName  := SProp.Name;
        Prop := SProp.Get_Value;
        //PropType := VarTypeAsText(VarType(Prop));
        PropValue := VarToStr(Prop);
        FResolution.MVideoController.Lines.Add('  + ' + PropName + '[' + PropType + '] = ' + PropValue);
 
      except
        on E: Exception do
        begin
           WriteLn(ErrOutput, PropName, ': ', E.Message);
        end;
      end;
    end;
  end;
end;
 
procedure TFResolution.BResolutionClick(Sender: TObject);
var
  Server: string;
  Enum: IEnumVARIANT;
  varArr: OleVariant;
  lNumElements: ULong;
  AName: array[0..255] of Char;
  ASize: DWORD;
begin
  if (ParamCount = 0) then
  begin
    Server := '';
    ASize  := SizeOf(AName) - 1;
    if GetComputerName(@AName, ASize) then Server := AName;
  end
  else
  begin
    Server := ParamStr(1);
  end;
  try
  //'Select * from Win32_videocontroller'
 
    MVideoController.Lines.BeginUpdate;
    Enum := CoSWbemLocator.Create.ConnectServer(Server, 'root\cimv2', '',
      '', '', '', 0, nil).ExecQuery('Select CurrentHorizontalResolution, CurrentVerticalResolution from Win32_videocontroller', 'WQL',
      wbemFlagBidirectional, nil)._NewEnum as IEnumVariant;
    while (Succeeded(ADsEnumerateNext(Enum, 1, varArr, lNumElements))) and
      (lNumElements > 0) do
    begin
      DumpWMI_Process(IUnknown(varArr) as SWBemObject);
    end;
  finally
    MVideoController.Lines.EndUpdate;
   //Select PelsHeight,PelsWidth from Win32_videocontroller;
    //Ligne 73 et position 37 les 4 dernier chiffres
    //EdWidth.Text := Copy(MVideoController.Lines[73], Pos('', MVideoController.Lines[73]) +37, Length(MVideoController.Lines[73])); //Width CurrentHorizontalResolution
 
EdWidth.Text := Copy(MVideoController.Lines[5], Pos('', MVideoController.Lines[5]) +37, Length(MVideoController.Lines[5])); //Width CurrentHorizontalResolution
 
 //Ligne 79 et position 35 les 4 dernier chiffres
    //EdHeight.Text := Copy(MVideoController.Lines[79], Pos('',MVideoController.Lines[79]) +35, Length(MVideoController.Lines[79])); //Height CurrentVerticalResolution
 
EdHeight.Text := Copy(MVideoController.Lines[6], Pos('',MVideoController.Lines[6]) +35, Length(MVideoController.Lines[6])); //Height CurrentVerticalResolution
  end;
end;
 
 
procedure TFResolution.Button2Click(Sender: TObject);
var
indexdelaligne : integer;
begin
indexdelaligne := SendMessage(MVideoController.Handle, EM_LINEFROMCHAR, MVideoController.SelStart, 0);
ShowMessage(IntToStr(indexdelaligne));
 
 
end;

@+,

cincap

**SergioMaster** · 02/10/2018, 17h05

Bonsoir,

cela me restait dans un coin de la tête ! Je n'ai jamais su s'il s'agissait d'une utilisation pour VCL ou FMX
il est évident que en FMX les WMI sont plus ou moins à oublier puisque spécifique Windows

en FMX je ferais ainsi

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
uses ... FMX.Platform;
 
procedure TForm20.Button1Click(Sender: TObject);
var
  ScreenService: IFMXScreenService;
  ScreenSize: TPoint;
  ScreenScale : Single;
begin
  if TPlatformServices.Current.SupportsPlatformService(
       IFMXScreenService, IInterface(ScreenService)) then
  begin
    ScreenSize := ScreenService.GetScreenSize.Round;
    ScreenScale:=ScreenService.GetScreenScale;
    Showmessage(Round(ScreenSize.X*ScreenScale).ToString + '  x ' + Round(ScreenSize.Y*ScreenScale).ToString);
  end;
end;

**cincap** · 02/10/2018, 19h06

Bonsoir à toutes et à tous,

@ SergioMaster, ta solution servira pour ceux qui travaille avec la version Delphi qui utilise FMX.

En ce qui me concerne, ma solution me suffit car comme déjà dit cela me permet d'avoir une indication pour régler ma forme (par rapport au bord) qui est posée sur la partie Horloge de la TrayIcon.

Cela me permet aussi d'obtenir avec précision la résolution d'un écran malgré une mise à l'échelle de plus de 100% sur Windows 10.

@+,

cincap

**cincap** · 03/10/2018, 09h12

Bonjour à toutes et à tous,

En persévérant, je me suis basé sur le calcul de la largueur de la barre des tâches qui en principe prend toute la largeur de l'écran peu importe son échelle de 100% ou 125%.

Voici le code que j'ai testé dans tous les sens et qui fonctionne sous Windows 10 même en modifiant les résolutions pour le test, pour les autres Os à tester.

Cela pourra certainement servir d'autant que la procédure est simplifiée :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
 
 
procedure TFresolution.BGoClick(Sender: TObject);
Var
AppData: TAppBarData;
PosStringA, PosStringB: string;
begin
  AppData.cbSize := sizeof(AppData);
  AppData.hWnd := FindWindow('Shell_TrayWnd', nil);
  SHAppBarMessage(ABM_GETTASKBARPOS, AppData);
 
  With AppData.rc do begin
 
    PosStringA := Format('%d', [Right]);
 
   PosStringB := Format('%d', [Bottom]);
 
end;
 
  Edwight.Text := PosStringA ;
 
  Edheight.Text := PosStringB;  
 
  end;

Bonne journée,

@+,

cincap

**tourlourou** · 03/10/2018, 20h26

Et si je choisis de la disposer verticalement, à gauche de l'écran ?

**cincap** · 03/10/2018, 23h55

@ tourlourou, bonsoir, en fait pour mon usage personnel, la barre de tâche est en bas en mode hide et donc j'obtiens la largeur et la hauteur exacte, il en est de même si elle est placée à droite.

C'est ce que je recherchais lors de la rédaction de mon 1er topic sans utiliser une procédure par un fichier *.bat.

A gauche comme en haut il y aura une valeur qui devrait changer mais qui donne quand même soit la largeur soit la hauteur totale de l'écran ce qui est plus juste qu'avec les procédures standard mise à part celle avec Wmi.

Voila voilou,

@+,

cincap

**cincap** · 19/10/2018, 11h09

Bonjour à toutes et à tous,

En fin de compte, j'ai donc modifié mon fichier "bat" pour à l'exécution tester la résolution de l'écran et ensuite sauvegarder les données dans un fichier texte.

J'ai inclus ce fichier "bat" dans une ressource pour mon programme Delphi.

Avec Delphi, à l'exécution du programme, le fichier ressource est sauvé dans le dossier de l'application, j'exécute le fichier "bat" en mode hide et récupère les données (lignes) du fichier text dans les composants Tedit qui se nomment "Width et Height".

Cela fonctionne correctement et très rapide.

@+,

cincap

Calcul de la résolution de l'écran sur Windows 10

Delphi

Discussions similaires

Partager

Partager