Discussion :

[cincap]

Bonjour à toutes et à tous,

Avec la procédure standard pour connaitre la résolution de mon écran qui fait 1920 x 1080, mon code donne un autre résultat soit (1536 x 864).

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
procedure TForm1.FormActivate(Sender: TObject);
var
HH :HDC;
hauteur, largeur:integer;
begin
HH:=getdc(GetDesktopWindow);
  largeur:=GetDeviceCaps(HH,HORZRES);
  hauteur:=GetDeviceCaps(HH,VERTRES);
  Edtwidth.text := inttostr(largeur);
  Edtheight.text := inttostr(hauteur);
end;

Il y a surement une explication.

@+,


cincap

[ALWEBER]

Bonjour à toutes et à tous,

Avec la procédure standard pour connaitre la résolution de mon écran qui fait 1920 x 1080, mon code donne un autre résultat soit (1536 x 864).
...
Il y a surement une explication.

@+,


cincap

essaye avec ce code

Code :

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

1
2
 
Form1.Caption := Screen.Width.ToString + ' ' + Screen.Height.ToString;

[Cirec]

Bonjour,

je suppose que tu es toujours sous D6 ...
teste voir ce code:

Code :

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

1
2
3
4
5
6
7
var
 DesktopRect: TRect;
begin
  SystemParametersInfo(SPI_GETWORKAREA, 0, @DesktopRect, 0);
  with DesktopRect do
    Caption := Format('%d x %d', [Right, Bottom]);
end;

il devrait fonctionner

Cordialement,
@+

[cincap]

@ ALWEBER, merci de ta suggestion mais cela ne fonctionne pas en D6 sur Windows 10.

@ Cirec, Comment vas tu mon mentor, merci de ta suggestion et j'obtiens le même résultat soit 1536 x 864, par contre cette méthode est nettement simplifiée comme d'habitude.

A mon avis il y a d'autres paramètres ou pixels qui jouent avec ce code.

Je teste aussi.

Avec ce code j'obtiens aussi 1536 x 864.

Code :

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

1
2
3
4
 
MessageDlg('Largeur de l''écran = ' + IntToStr( Screen.Width ) + 
  ' pixels, Hauteur de l''écran = ' + IntToStr( Screen.Height )+' pixels', 
  mtInformation, [mbOk], 0 );

@+,


cincap

[cincap]

Euréka, j'ai trouvé la cause, en effet dans les paramètres de l'affichage de Windows 10, le poste "Mise à l'échelle et disposition" puis "Modifier la taille du texte, des applications et d'autres éléments" le réglage était sur 125% (Recommandé).


Tous les codes fonctionnent en mettant ce paramètre sur 100% j'obtiens bien la résolution de 1920 x 1080.


Je ne pense pas qu'il y a une autre solution avec ce même réglage de 125%.

@+,

cincap

[cincap]

Bonjour à toutes et à tous,

Je pensais ne pourrait t'on pas inclure un champ ou on pourrait indiquer ce fameux 25% dans le code de recherche de la résolution pour tester les réelles dimensions de l'écran sans modifier ce qui est recommandé par Windows 10 ?

Merci à tous,

@+,

cincap

[SergioMaster]

Bonjour,
la question serait plutôt : comment obtenir l'échelle ?

Après tout, 1536 x 864 *1.25 => 1920 x 1080.

Il serait peut être intéressant de fouiller du côté des WMI root/cimv2/win32_displayconfiguration qui devrait fournir les valeurs 1920 x 1080 (pelswidth, pelsHeight)

[ALWEBER]

@ ALWEBER, merci de ta suggestion mais cela ne fonctionne pas en D6 sur Windows 10.
...

voici le code associé à screen.with et screen height

Code :

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

1
2
3
4
5
6
7
8
9
10
 
function TScreen.GetHeight: Integer;
begin
  Result := GetSystemMetrics(SM_CYSCREEN);
end;
 
function TScreen.GetWidth: Integer;
begin
  Result := GetSystemMetrics(SM_CXSCREEN);
end;

GetSystemMetrics est une fonction Microsoft

[ShaiLeTroll]

Si Screen.PixelsPerInch est à 120 au lieu 96, tu peux retrouver ton information de 1.25


Dans mes applications, je gère le zoom depuis genre XP
Avec Windows 7, il devenait très facile de changer la taille de police en 100/125/150, j'ai eu quelques très rares utilisateurs en 125 ou 150, j'ai donc été confronté à ce problème
je crois pas me tromper mais je détecte cela et considére que l'application est déjà zoomé grâce à Screen.PixelsPerInch

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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
 
  /// <summary>Assistance de la classe TForm, en particulier la Méthode ScaleBy</summary>
  /// <remarks>Le TFormScaleSLTAssistant n'est pas un class helper car lors de sa création la version utilisée était Delphi7 puis C++Builder2007
  /// Traduction C++Builder vers Delphi en concervant ce concept des Assistances de classes (Class Helper) du Delphi.NET</remarks>
  TFormScaleSLTAssistant = class(TObject)
  private
    const
      DPI_BASE = 96;
      DPI_STEP = 24;
      POURCENT_BASE = 100;
      POURCENT_STEP = 25;
  private
    class var FMaxZoom: Integer;
    class var FReferenceZoom: Integer;
    class var FCurrentZoom: Integer;
    class var FSpecificZooms: System.Generics.Collections.TDictionary<TForm, Integer>;
    class var FBeforeZoom: TFormScaleSLTAssistantBeforeZoomEvent;
    class var FAfterZoom: TFormScaleSLTAssistantAfterZoomEvent;
 
    class function DoBeforeZoom(AForm: TForm; ZoomFrom: Integer; var ZoomTo: Integer): Boolean;
    class procedure DoAfterZoom(AForm: TForm; ZoomFrom: Integer; ZoomTo: Integer);
    class procedure CheckBounds(AForm: TForm);
 
    class procedure ScaleBy(AWinControl: TWinControl; M, D: Integer);
  public
    class constructor Create();
    class destructor Destroy();
 
    /// <summary>BuildChangeZoomMenu ajoute comme menus enfants dans un TMenuItem listant plusieurs niveau de Zoom</summary>
    /// <param name="AMenuZoom">Menu dans lequel seront insérés comme sous-menu chaque niveau de zoom géré par l'application</param>
    /// <param name="AOnClick">Gestionnaire d'évèmenent commun à chaque sous-menu, le Tag permet de trouver le style concerné, il recommandé d'utiliser ZoomClickDefaultEventHandler</param>
    /// <param name="ADefaultZoom">Zoom fixé à l'origine</param>
    /// <param name="AMaxZoom">Zoom maximum qui sera disponible dans le menu</param>
    /// <returns>Zoom actuel</returns>
    class function BuildChangeZoomMenu(AMenuZoom: TMenuItem; AOnClick: TNotifyEvent; ADefaultZoom: Integer = -1; AMaxZoom: Integer = 200): Integer;
 
    class procedure ZoomClickDefaultEventHandler(Sender: TObject);
    class procedure ZoomAllForms(AZoom: Integer);
    class procedure ApplyCurrentZoom(AForm: TForm);
    class procedure ApplyCurrentZoomToControl(AControl: TWinControl);
    class function ApplySpecificZoom(AForm: TForm; AZoom: Integer): Integer;
    class procedure CancelZoom(AForm: TForm);
    class procedure UnregisterZoom(AForm: TForm);
    class property CurrentZoom: Integer read FCurrentZoom;
    class property ReferenceZoom: Integer read FReferenceZoom;
    class property BeforeZoom: TFormScaleSLTAssistantBeforeZoomEvent read FBeforeZoom write FBeforeZoom;
    class property AfterZoom: TFormScaleSLTAssistantAfterZoomEvent read FAfterZoom write FAfterZoom;
  end;
 
 
...
 
 
 
//------------------------------------------------------------------------------
class function TFormScaleSLTAssistant.BuildChangeZoomMenu(AMenuZoom: TMenuItem; AOnClick: TNotifyEvent; ADefaultZoom: Integer = -1; AMaxZoom: Integer = 200): Integer;
var
  I, MaxI: Integer;
  DPI, Pourcent: Integer;
  Sub: TMenuItem;
begin
  AMenuZoom.AutoHotkeys := maManual;
  AMenuZoom.Clear();
 
  MaxI := Round((AMaxZoom - POURCENT_BASE) / POURCENT_STEP);
  FMaxZoom := POURCENT_BASE + MaxI * POURCENT_STEP;
  if ADefaultZoom > FMaxZoom then
    ADefaultZoom := FMaxZoom;
 
  for I := 0 to MaxI do
  begin
    DPI := DPI_BASE + I * DPI_STEP;
    Pourcent := POURCENT_BASE + I * POURCENT_STEP;
 
    Sub := TMenuItem.Create(AMenuZoom);
    AMenuZoom.Add(Sub);
    Sub.Tag := Pourcent;
    Sub.RadioItem := True;
    Sub.GroupIndex := 1;
    Sub.AutoHotkeys := maManual;
    Sub.Caption := IntToStr(Pourcent) + ' %';
 
    if CheckWin32Version(6, 0) and (Screen.PixelsPerInch = DPI) then
      FReferenceZoom := Pourcent;
 
    if (POURCENT_BASE <= ADefaultZoom) and (ADefaultZoom <= FMaxZoom) then
    begin
      if ADefaultZoom = Pourcent then
      begin
        FCurrentZoom := Pourcent;
        Sub.Checked := True;
      end;
    end
    else
    begin
      if CheckWin32Version(6, 0) and (Screen.PixelsPerInch = DPI) then
      begin
        FCurrentZoom := Pourcent;
        Sub.Checked := True;
      end
      else
      begin
        if Pourcent = POURCENT_BASE then
        begin
          FCurrentZoom := Pourcent;
          Sub.Checked := True;
        end;
      end;
    end;
 
    Sub.OnClick := AOnClick;
  end;
 
  if AMenuZoom.Owner is TForm then
    ApplyCurrentZoom(TForm(AMenuZoom.Owner));
 
  Result := FCurrentZoom;
end;

@ALWEBER, c'est le .ToString qui je pense était source d'erreur de compilation pour Cincap






Alors pour conclure si Screen.PixelsPerInch change bien en Win10 comme en Win7, tu peux tenter cela

Code :

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

1
2
3
4
 
    MessageDlg(Format('Largeur de l''écran = %d pixels, Hauteur de l''écran = %d pixels'
                   , [Screen.Width * IfThen(CheckWin32Version(6, 2), Screen.PixelsPerInch div 96, 1), Screen.Height * IfThen(CheckWin32Version(6, 2), Screen.PixelsPerInch div 96, 1)])
            , mtInformation, [mbOk], 0);

[cincap]

@ ShaiLeTroll, merci pour ta suggestion,

cela bloque au niveau du ifthen, j'ai essayé de le séparer mais même problème.

MessageDlg(Format('Largeur de l''écran = %d pixels, Hauteur de l''écran = %d pixels'
, [Screen.Width * IfThen(CheckWin32Version(6, 2), Screen.PixelsPerInch div 96, 1), Screen.Height * IfThen(CheckWin32Version(6, 2), Screen.PixelsPerInch div 96, 1)])
, mtInformation, [mbOk], 0);

Petite question on ne saurai pas modifier les procédures déjà communiquées en indiquant et ajoutant "1.25" suivant l'échelle de Windows 10.

@+,

cincap

[cincap]

@ tous, j'ai trouvé une solution avec une procédure déjà décrite dans ce topic et en tenant compte du facteur de l'échelle 1.25.

Maintenant pas fort professionnel mais cela fonctionne !

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
 
procedure TForm1.Button8Click(Sender: TObject);
 var
 
 DesktopRect: TRect;
 
 n1 : Extended;
 n2 : extended;
 
 n3 : Extended;
 n4 : extended;
 
begin
 
    SystemParametersInfo(SPI_GETWORKAREA, 0, @DesktopRect, 0) ;
  with DesktopRect do begin
 
  Edtwidth.Text := Format('%d', [Right]);
  Edtheight.Text := Format('%d', [Bottom]);
end;
 
    n1 := strtofloat(Edtwidth.text);
 
    n2 := (n1 *1.25);
 
    n3 := strtofloat(Edtheight.text);
 
    n4 := (n3 *1.25);
 
       sleep(10);
 
  Edtwidth.Text := floattostr(n2);
  Edtheight.Text := floattostr(n4) ;
end;

@+,


cincap

[ShaiLeTroll]

@ ShaiLeTroll, merci pour ta suggestion,

cela bloque au niveau du ifthen, j'ai essayé de le séparer mais même problème.



Petite question on ne saurai pas modifier les procédures déjà communiquées en indiquant et ajoutant "1.25" suivant l'échelle de Windows 10.

@+,

cincap

As-tu vérifier quand même si Screen.PixelsPerInch contenait autre chose que 96 pour justement calculer le 1.25 (120) ou 1.50 (144) selon l'échelle

Et pour le IfThen suffit d'ajouter l'unité Math qui existe en D6

@ tous, j'ai trouvé une solution avec une procédure déjà décrite dans ce topic et en tenant compte du facteur de l'échelle 1.25.

Tu as loupé la véritable bonne intervention de SergioMaster qui évoquat les WMI sur root/cimv2/win32_displayconfiguration

Pour le code ci dessus est si long

Code :

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

1
2
3
4
5
6
7
8
9
10
11
procedure TForm1.Button8Click(Sender: TObject);
var 
 DesktopRect: TRect;
begin
  SystemParametersInfo(SPI_GETWORKAREA, 0, @DesktopRect, 0) ;
  with DesktopRect do 
  begin 
    Edtwidth.Text := Format('%d', [Right * 5 div 4]);
    Edtheight.Text := Format('%d', [Bottom * 5 div 4]);
  end;
end;

[cincap]

@ ShaiLeTroll, j'ai toujours une erreur sur "CheckWin32Version".

En effet j'ai loupé Wmi et je remercie SergioMaster.

Pour la simplification du code c'est ok naturellement venant de toi.


Je vais voir avec Wmi ce que je pourrai faire.

@+,


cincap

[ShaiLeTroll]

CheckWin32Version c'est dans SysUtils et mes souvenirs sont flous mais si j'en crois ce que je lis ça existe en D6 et l'aide contient cette Remarque "Avant Delphi 7, cette routine renvoyait un résultat différent" donc méfiance avec la version de D6

Donc voici la version que j'ai a utilise à la place de celle de D6

Code :

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

1
2
3
4
5
function CheckWin32Version(AMajor: Integer; AMinor: Integer = 0): Boolean;
begin
  Result := (Win32MajorVersion > AMajor) or
            ((Win32MajorVersion = AMajor) and
             (Win32MinorVersion >= AMinor));

Tu n'as toujours pas dit ce que contenant Screen.PixelsPerInch ?

Un code que j'espère compatible D6 sans des uses que tu ne sembles pas connaitre

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
procedure TForm1.Button8Click(Sender: TObject);
 
  function GetScreenResolutionCorrection(V: Integer): Integer;
  begin
    if  (Win32MajorVersion > 6) or ((Win32MajorVersion = 6) and (Win32MinorVersion >= 2)) then
      Result := V * Screen.PixelsPerInch div 96
    else
      Result := V;
  end;
 
var 
 DesktopRect: TRect;
begin
  SystemParametersInfo(SPI_GETWORKAREA, 0, @DesktopRect, 0) ;
  with DesktopRect do 
  begin 
    Edtwidth.Text := Format('%d', [GetScreenResolutionCorrection(Right)]);
    Edtheight.Text := Format('%d', [GetScreenResolutionCorrection(Bottom)]);
  end;
end;

[Andnotor]

C'est le redimensionnement des applications non manifest-ées qui entraîne ces différences de largeur/hauteur.
Ajouter un manifest contenant le support du HighDPI (dpiAware) corrige cela.

[cincap]

@ ShaiLeTroll, ce code fonctionne très bien mais il indique ce que les autres indiquent c'est à dire "1536 x 864".

C'est en fait la surface utile de l'écran mais pas la résolution de l'écran.

Je ne trouve pas avec Wmi, car j'avais une Vcl avec des composants Wmi mais lors de l'interrogation du composant display il m'indique une autre résolution fantaisiste donc pas très fiable.

@ Andnotor, merci de ton intervention mais je n'ai pas bien compris la solution du manifest car je pourrai aussi bien modifier le paramètre de 125% par défaut en 100% et toutes les solutions fonctionnent et m'indiquent la résolution exacte "1920 x 1080".

Maintenant ce n'est pas un problème en soi, car c'est une information qui me permettrai de régler une distance par rapport au bord droit de l'écran suivant une résolution définie de l'écran.

@+,


cincap

[Andnotor]

@ Andnotor, merci de ton intervention mais je n'ai pas bien compris la solution du manifest car je pourrai aussi bien modifier le paramètre de 125% par défaut en 100% et toutes les solutions fonctionnent et m'indiquent la résolution exacte "1920 x 1080".

C'est le cas de toutes les applications DPIAware.

Maintenant ce n'est pas un problème en soi, car c'est une information qui me permettrai de régler une distance par rapport au bord droit de l'écran suivant une résolution définie de l'écran.

Et bien ça ne fonctionnera pas.

Lorsque tu modifies la mise à l'échelle, Windows agrandit "artificiellement" les fiches des apps qui ne supporte pas cette mise à l'échelle (ça entraîne l'effet de floutage qu'on constate sur les anciennes applications). Ta fiche D6 est donc rendue plus grande que ce que tu as défini au design (125% plus grande dans ton cas).

Mais cela implique que tous les appels aux API doivent en tenir compte. L'OS te fournit donc une taille d'écran réduite par rapport à la réalité tout comme il va adapter tous les appels concernant le positionnement ou la taille (en lecture et écriture). C'est totalement transparent pour toi.

Le test est très vite fait, à 125%, essaie d'aligner la fiche sur le bord droit. Avec Form1.Left := 1920 -Form1.Width, la fiche est hors écran. Avec Form1.Left := Screen.Width -Form1.Width, le résultat est celui attendu.

Bien sûr, activer le HighDPI sous D6 n'est pas anodin puisque ce sera à toi de positionner/dimensionner correctement les champs sur la fiche en fonction de l'échelle (les Delphi récents le font automatiquement).

Résultat des courses, tu as meilleur temps de laisser ton app telle quelle et de te baser uniquement sur ce que te fournit Windows, sans chercher à contourner cela d'aucune manière

[SergioMaster]

Pour revenir sur les WMI

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
//-----------------------------------------------------------------------------------------------------
//     This code was generated by the Wmi Delphi Code Creator (WDCC) Version 1.9.9.350
//     http://code.google.com/p/wmi-delphi-code-creator/
//     Blog http://theroadtodelphi.wordpress.com/wmi-delphi-code-creator/
//     Author Rodrigo Ruz V. (RRUZ) Copyright (C) 2011-2015 
//----------------------------------------------------------------------------------------------------- 
//
//     LIABILITY DISCLAIMER
//     THIS GENERATED CODE IS DISTRIBUTED "AS IS". NO WARRANTY OF ANY KIND IS EXPRESSED OR IMPLIED.
//     YOU USE IT AT YOUR OWN RISK. THE AUTHOR NOT WILL BE LIABLE FOR DATA LOSS,
//     DAMAGES AND LOSS OF PROFITS OR ANY OTHER KIND OF LOSS WHILE USING OR MISUSING THIS CODE.
//
//----------------------------------------------------------------------------------------------------
program GetWMI_Info;
 
{$APPTYPE CONSOLE}
 
uses
  SysUtils,
  ActiveX,
  ComObj,
  Variants;
 
 
 
// La classe Win32_DisplayConfiguration représente les informations de 
// configuration du périphérique d’affichage sur un système Win32. Cette classe 
// est généralement remplacée par les propriétés de Win32_VideoController, 
// Win32_DesktopMonitor et CIM_VideoControllerResolution
 
procedure  GetWin32_DisplayConfigurationInfo;
const
  WbemUser            ='';
  WbemPassword        ='';
  WbemComputer        ='localhost';
  wbemFlagForwardOnly = $00000020;
var
  FSWbemLocator : OLEVariant;
  FWMIService   : OLEVariant;
  FWbemObjectSet: OLEVariant;
  FWbemObject   : OLEVariant;
  oEnum         : IEnumvariant;
  iValue        : LongWord;
begin;
  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
 
    Writeln('');
    FWbemObject:=Unassigned;
  end;
end;
 
 
begin
 try
    CoInitialize(nil);
    try
      GetWin32_DisplayConfigurationInfo;
    finally
      CoUninitialize;
    end;
 except
    on E:EOleException do
        Writeln(Format('EOleException %s %x', [E.Message,E.ErrorCode])); 
    on E:Exception do
        Writeln(E.Classname, ':', E.Message);
 end;
 Writeln('Press Enter to exit');
 Readln;      
end.

[cincap]

Bonjour à toutes et à tous,

@ SergioMaster, merci pour ta solution mais je suis un peu perdu pour l'utiliser sur une Fiche.


@ Andnotor, merci pour tes explications toujours au top mais pour préciser mon intérêt, c'est toujours pour mon Tlabel sur une Tform qui se superpose sur l'affichage de l'heure dans la TrayIcon et qui me donne l'heure vocalement.


Dans cette application personnelle j'ai prévu une fiche de configuration avec un TSpinEdit (Sp1) pour modifier la distance par rapport au bord droit de la TrayIcon suivant l'Os car pour Windows 10 je suis à +361 alors que pour Seven j'étais à -2 :

Code :

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

1
2
3
4
5
6
7
8
9
10
 
 
 
//Windows Seven 64bits
 
{larg := Tray_taille.right - Tray_taille.left ;
  haut := Tray_taille.bottom - Tray_taille.top -5;
  MoveWindow(Trayform.handle, Tray_taille.left - taille2.left -2,
    Tray_taille.top - taille2.top +2, larg,
    haut, true);}

Code :

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

1
2
3
4
5
6
7
8
 
 
//Windows 10 64bits - Andnotor
 
  larg := Tray_taille.right +8 - Tray_taille.left ;
  haut := Tray_taille.bottom - Tray_taille.top; // - 2;
  MoveWindow(Trayform.handle, Tray_taille.left -2 - taille2.left + trayform.Sp1.value,
    Tray_taille.top +4 - taille2.top, larg, haut, true);

Donc je détecte la résolution pour justifier 361 qui ne sert que comme indication donc à rien.


Pour la solution simplifiée de ShaiLeTroll cela fonctionne si l'échelle est à 125% mais si elle est à 100%, cela me donne une autre indication.

@+,


cincap

[cincap]

@ tous, pour info

J'ai testé avec un fichier *.bat et la il affiche bien 1920 x 1080 sans tenir compte de l'échelle par contre au niveau de regedit, je n'ai rien trouvé pour Windows 10 ou l'information n'est pas à la même place que sur Seven.

@+,

cincap