FAQ DelphiConsultez toutes les FAQ

Nombre d'auteurs : 123, nombre de questions : 920, dernière mise à jour : 8 novembre 2019  Ajouter une question

 

Cette FAQ a été réalisée à partir des questions fréquemment posées sur les forums Delphi et Delphi et bases de données de www.developpez.com et de l'expérience personnelle des auteurs.

Nous tenons à souligner que cette FAQ ne garantit en aucun cas que les informations qu'elle propose soient correctes. Les auteurs font le maximum, mais l'erreur est humaine. Cette FAQ ne prétend pas non plus être complète. Si vous souhaitez y apporter des corrections ou la compléter, contactez un responsable (lien au bas de cette page).

Nous espérons que cette FAQ saura répondre à vos attentes. Nous vous en souhaitons une bonne lecture.

L'équipe Delphi de Developpez.com.

Commentez


SommaireSystèmeMoniteur, écran et affichage (11)
précédent sommaire suivant
 

Pour connaître la résolution de l'écran, inutile de faire appel aux API de Windows. Il existe sous Delphi la variable Screen qui permet de l'obtenir.
La variable Screen est un composant TScreen qui représente l'écran du système sur lequel fonctionne l'application Delphi. Par défaut, les applications créent un composant écran fondé sur les informations fournies par Windows sur le périphérique écran en cours et l'affectent à Screen.

  • Screen.Width : Integer indique la hauteur, exprimée en pixels, de l'écran ;
  • Screen.Height : Integer indique la largeur, exprimée en pixels, de l'écran.

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

Mis à jour le 18 octobre 2013 atlantis

Il suffit pour cela de se servir de la fonction SendMessage fournie par l'API Windows :

Code : Sélectionner tout
SendMessage(Application.Handle, WM_SYSCOMMAND, SC_MONITORPOWER, 1);
Cette fonction marche avec toutes les versions de Windows.

Mis à jour le 18 octobre 2013 Al-Yazdi

Dans certains cas, il est pratique qu'au lancement du programme celui-ci désactive l'écran de veille ainsi que la mise en veille du moniteur. Pour cela, nous allons utiliser l'API

Code delphi : Sélectionner tout
SystemParametersInfo (uiAction : Cardinal; uiParam : Cardinal; pvParam : Pointer; fWinIni : Cardinal)
de l'unité ShellApi.
Code delphi : Sélectionner tout
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
uses 
  ShellApi; 
  
const 
  WinIni = SPIF_UPDATEINIFILE; 
  
var 
Param: DWord; 
  
{Au lancement de l'application on modifie les valeurs d'attente } 
procedure TMyForm.FormCreate(Sender: TObject); 
begin 
  {Ecran de veille : } 
  {Si l'écran de veille est actif } 
  if not SystemParametersInfo(SPI_GETSCREENSAVEACTIVE, 0, nil, WinIni) then 
  {Alors on le désactive } 
  SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, 0, nil, WinIni); 
  
  {Mise en veille moniteur : } 
  {On récupère le temps d'attente avant la mise en veille } 
  SystemParametersInfo(SPI_GETPOWEROFFTIMEOUT, 0, @Param, WinIni); 
  {Si cette valeur est supérieur à zéro } 
  if Param > 0 then 
    {Alors on désactive la mise en veille } 
    SystemParametersInfo(SPI_SETPOWEROFFTIMEOUT, 0, nil, WinIni); 
end; 
  
{A la fermeture de l'application on rétablit les valeurs } 
procedure TMyForm.FormClose(Sender: TObject; var Action: TCloseAction); 
begin 
  {Ecran de veille : } 
  if not SystemParametersInfo(SPI_GETSCREENSAVEACTIVE, 1, nil, WinIni) then 
    SystemParametersInfo(SPI_SETSCREENSAVEACTIVE, 1, nil, WinIni); 
  
  {Mise en veille moniteur : } 
  if Param > 0 then 
    SystemParametersInfo(SPI_SETPOWEROFFTIMEOUT, Param, nil, WinIni); 
end;
Ceci fonctionne avec toutes les versions de Windows.

Mis à jour le 14 janvier 2014 Gysmo

Voici une fonction qui fait cela très bien :

Code delphi : Sélectionner tout
1
2
3
4
5
6
7
8
Function ChangeResolution(Width,Height:Integer):Boolean; 
Var Dev:TDeviceMode; 
begin 
  Dev.dmPelsWidth := Width; 
  Dev.dmPelsHeight:= Height; 
  Dev.dmFields     := DM_PELSWIDTH Or DM_PELSHEIGHT; 
  Result:=ChangeDisplaySettings(Dev,0)=DISP_CHANGE_SUCCESSFUL; 
end;
Cette fonction ne teste pas si votre écran supporte la résolution que vous souhaitez. Prévoyez au cas où dans votre développement de pouvoir revenir à la résolution précédente.

Mis à jour le 18 octobre 2013 atlantis

Si dans votre application vous changez la résolution de l'écran, il est possible de revenir à celle par défaut (celle utilisée au démarrage de Windows). Pour cela utilisez la fonction suivante :

Code delphi : Sélectionner tout
1
2
3
4
5
6
7
8
9
{ Déclaration de la fonction API } 
function _DefaultDisplaySettings(Zero:Integer; dwFlags: DWORD): Longint; 
    stdcall;external user32 name 'ChangeDisplaySettingsA'; 
  
{ Procédure de retour à la résolution par défaut. } 
Procedure ResolutionParDefaut; 
Begin 
  _DefaultDisplaySettings(0,0); 
End;
Un simple appel de ResolutionParDefaut permet donc de rétablir la résolution utilisée au démarrage.

Mis à jour le 18 octobre 2013 Nono40

La réalisation de cette opération dépasse le cadre de cette FAQ mais vous pouvez utiliser ou vous inspirer du composant disponible à l'adresse suivante ci-dessous :

Mis à jour le 17 janvier 2014 Pierre Castelain

Pour faire une copie d'écran, il faut copier la fenêtre du bureau Windows (desktop window). Celle-ci contient l'image complète de ce qui apparaît à l'écran. Une fonction de l'API Windows nous permet facilement de récupérer le handle de cette fenêtre : GetDesktopWindow.
Une fois ce handle obtenu, il nous faut récupérer le contexte de périphérique GDI de cette fenêtre avec la fonction GetDC. Celui-ci nous permet d'accéder à l'image de la fenêtre en utilisant les fonctions adéquates de l'API.
Il ne reste plus qu'à dimensionner correctement notre image et à copier le contenu du contexte de périphérique en utilisant la fonction BitBlt.
Nous aurions également pu créer un objet TCanvas et lui associer le contexte de périphérique. De cette façon, il aurait été possible d'utiliser directement les méthodes du TCanvas pour copier l'image.

Code delphi : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
procedure ScreenShot(const Filename: string); 
var 
  bitmap: TBitmap; 
  desktopHandle: THandle; 
  deviceContext: HDC; 
begin 
  desktopHandle:= GetDesktopWindow; // Récupération du handle du bureau 
  deviceContext:= GetDC(desktopHandle); // Récupération du contexte de périphérique du bureau 
  
  bitmap:= TBitmap.Create; // Création d'une image bitmap 
  try 
    bitmap.Width:= Screen.Width; // Ajustement de la taille de l'image 
    bitmap.Height:= Screen.Height; // pour qu'elle corresponde à celle du bureau 
  
    BitBlt(bitmap.Canvas.Handle, 0, 0, bitmap.Width, bitmap.Height, 
      deviceContext, 0, 0, SRCCOPY); // Copie du bureau dans l'image bitmap 
  
    bitmap.SaveToFile(Filename); // Sauvegarde de l'image dans un fichier bmp 
  finally 
    bitmap.Free; // Libération de l'image 
    ReleaseDC(desktopHandle, deviceContext); // Libération du contexte de périphérique 
  end; 
end;

Mis à jour le 14 janvier 2014 Pierre Castelain

Récupérer les informations concernant les polices utilisées dans une application Delphi est évident : Il suffit de consulter les attributs des propriétés de type TFont. Par contre, nous n'avons pas accès à toutes les polices. Par exemple la police utilisée pour la barre de titre n'est pas disponible directement. Il nous faut donc utiliser une fonction de l'API Windows : SystemParametersInfo
Voici un exemple d'utilisation de cette fonction. Le code suivant récupère juste le nom de la police de la barre de titre, mais vous pouvez le modifier facilement en utilisant les variables du record metrics.lfCaptionFont

Code delphi : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
function GetTitleBarFontName: string; 
var 
  metrics: NONCLIENTMETRICS; 
begin 
  metrics.cbSize:= SizeOf(metrics); 
  if SystemParametersInfo(SPI_GETNONCLIENTMETRICS, SizeOf(metrics), @metrics, 0) then 
    result:= metrics.lfCaptionFont.lfFaceName 
  else 
    result:= ''; 
end;

Mis à jour le 14 janvier 2014 Pierre Castelain

Si vous désirez réaliser une interface graphique qui soit utilisable sur tous les systèmes de vos utilisateurs, vous allez peut-être vouloir connaître la taille de la police d'affichage afin d'adapter votre interface en fonction. Ce paramètre, qui peut être modifié par le panneau de configuration de l'affichage, a un impact non négligeable sur l'aspect des fenêtres réalisées en Delphi. En effet, les fenêtres héritant de TForm utilisent cette taille comme taille par défaut de leur propre police. Pour obtenir cette information, un simple appel à la fonction GetDeviceCaps suffit.
La fonction d'exemple suivante vous retourne directement la taille de la police. Les valeurs principales sont :

  • 96 pour une petite police
  • 120 pour une grande police
  • et n'importe quelle autre valeur si l'utilisateur l'a spécifiée (relativement rare)

Code delphi : Sélectionner tout
1
2
3
4
5
6
7
8
function GetSystemFontSize: Integer; 
var 
  dc: HDC; 
begin 
  dc:= GetDC(0); 
  result:= GetDeviceCaps(dc, LOGPIXELSX); 
  ReleaseDC(0, dc); 
end;

Mis à jour le 14 janvier 2014 Pierre Castelain

Au préalable, il faut créer la ressource contenant le curseur à l'aide de l'éditeur d'image de Delphi et intégrer cette ressource dans le source du projet à l'aide de la directive de compilation :

Code delphi : Sélectionner tout
{$R NomDeMaRessource.res}
Ensuite, il faut définir une constante pour notre nouveau curseur (veuillez à ne pas prendre des valeurs de contante existantes qui sont pour la pluspart négatives, il est conseillé de prendre des valeurs comprises entre 1 et High(Integer)).

Dans le code, il suffira ensuite d'utiliser la fonction LoadCursor pour récupérer le curseur à partir du fichier ressources précédemment cré& et l'affecter soit à un composant particulier de la fiche, soit à la fiche toute entière, cette fonction prend en paramètre le nom du curseur tel que vous l'avez nommé dans la ressource (dans l'exemple ci-dessus 'MonCurseur')
Code delphi : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
const 
     crMoncurseur = 3; //Par exemple 
  
....//instructions diverses 
  
procedure TMainForm.FormCreate(Sender: TObject); 
begin 
     Screen.Cursors[crMonCurseur] := LoadCursor(hInstance,'MonCurseur'); 
//     Screen.Cursor := crMonCurseur;//Affecte le curseur crée à la fiche entière 
    btnTest.Cursor := crMonCurseur; //Affecte le curseur crée à un boutton 
end;

Mis à jour le 14 janvier 2014 Giovanny Temgoua

Lien MSDN : fonction LoadCursor

Il suffit d'utiliser les fonctions API FindWindow et ShowWindow.

La première servira à retrouver le processus qui nous intéresse (ici Progman) et la seconde lui enverra un message SW_HIDE pour le cacher.
Pour cacher, il suffit donc de faire :

Code delphi : Sélectionner tout
ShowWindow(FindWindow('Progman',nil),SW_HIDE);
Pour réafficher :
Code delphi : Sélectionner tout
ShowWindow(FindWindow('Progman',nil),SW_RESTORE);

Mis à jour le 14 janvier 2014 Lung

Lien MSDN : fonction FindWindow
Lien MSDN : fonction ShowWindow

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2019 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.