read Windows Font Size

In a Delphi program I display text from a textfile, with
a specifiable font size on a window.
The problem off course is, that when someone on the network
has changed his
Start->Settings->Control Panel->Display->Setting->Font Size
setting to Large fonts, he can't read all of the text.

My question is:

  How can I determiner this setting in delphi (remember
  a Windows APi call, but I can get the use of parameters
  right, so please give a example procedure).

  How can I map these large fonts to small fonts
  ,calculate the font size to use (
  I mean I want the person with the large fonts settings
  to see the same size of the text in my programwindow,
  he would see if you used the small fonts settings).
  Can I just divide a certain font size by half?
  Is this a constant?

Who is Participating?
Use the GetSysFont function from the following unit to determine the 6 designated system font:

{ ------------------------------------------------------------------------- }
{ Description:                                                              }
{    Retrieves fonts assigned to the system screen elements.                }
{                                                                           }
{ Declaration:                                                              }
{    Function GetSysFont(FontParam: TSysFont; var ResFont: TFont): Boolean; }
{                                                                           }
{ Parameters:                                                               }
{    FontParam - Enumerated type that specifies the system font to          }
{    retrieve. This is one of the following values: sfCaptionFont,          }
{    sfSmCaptionFont, sfMenuFont, sfStatusFont, sfMessageFont, sfIconFont.  }
{                                                                           }
{    ResFont - A TFont variable that can be used to store the resulting     }
{    TFont object.                                                          }
{ ------------------------------------------------------------------------- }
unit SysFont;


      SysUtils, Windows, Graphics;

       TSysFont = (sfCaptionFont, sfSmCaptionFont, sfMenuFont,
                  sfStatusFont, sfMessageFont, sfIconFont);

Function GetSysFont(FontParam: TSysFont; var ResFont: TFont): Boolean;
procedure TFontFromLogFont(const LogFont: TLogFont; var NewFont: TFont);


{ Gets the System font setting of the passed TSysFont parameter }
Function GetSysFont(FontParam: TSysFont; var ResFont: TFont): Boolean;
      TempNonClientMetrics: TNonClientMetrics;
      TempLogFont: TLogFont;
      ret: boolean;
      Result := false;
      If FontParam = sfIconFont then
            { The IconFont is retreived with a different method
                  than all the other system fonts }
            ret := SystemParametersInfo(SPI_GETICONTITLELOGFONT,
                        SizeOf(TempLogFont), @TempLogFont, 0)
                  TempNonClientMetrics.cbSize := SizeOf(TempNonClientMetrics);
                  ret := SystemParametersInfo(SPI_GETNONCLIENTMETRICS, 0,
                              @TempNonClientMetrics, 0);

      { If call to SystemParametersInfo() not successful then exit}
      If not ret then exit;

      { Load appropriate TempNonClientMetrics field into TempLogFont }
      case FontParam of
                  TempLogFont := TempNonClientMetrics.lfCaptionFont;
                  TempLogFont := TempNonClientMetrics.lfSmCaptionFont;
                  TempLogFont := TempNonClientMetrics.lfMenuFont;
                  TempLogFont := TempNonClientMetrics.lfStatusFont;
                  TempLogFont := TempNonClientMetrics.lfMessageFont;

      { Convert TempLogFont into a TFont }
      TFontFromLogFont(TempLogFont, ResFont);
      Result := true;

{ Converts a LogFont structure to a Delphi TFont }
procedure TFontFromLogFont(const LogFont: TLogFont; var NewFont: TFont);
      Style: TFontStyles;
      with LogFont do
            NewFont.Name := lfFaceName;
            NewFont.Height := lfHeight;
            Style := [];

            if lfWeight > FW_REGULAR then Include(Style, fsBold);
            if lfItalic <> 0 then Include(Style, fsItalic);
            if lfUnderline <> 0 then Include(Style, fsUnderline);
            if lfStrikeOut <> 0 then Include(Style, fsStrikeOut);

            NewFont.Style := Style;

Can't you use TFont.size property for calculating You'r display ?
When text is (in example) in TMemo then user can use ScrollBars so tell more what happened and what you need because i can't understand.
You want the text metrics for the font.

  DC: HDC;
  SaveFont: HFont;
  Metrics: TTextMetric;

DC := GetDC(0);
SaveFont := SelectObject( DC, Font.Handle);
GetTextMetrics(DC, Metrics );
SelectObject(DC, SaveFont);
ReleaseDC(0, DC);

Now, you have use of the metrics, like:

MyHeight := Metrics.tmHeight + 3;

Hope this helps.

Ian C.

Cloud Class® Course: Microsoft Azure 2017

Azure has a changed a lot since it was originally introduce by adding new services and features. Do you know everything you need to about Azure? This course will teach you about the Azure App Service, monitoring and application insights, DevOps, and Team Services.

mosiAuthor Commented:

Thanx ICAMPBEL, but I rejected your answer, althrough it probably contains part of the answer, but it is not so complete that I can use it. Please clarify!

I tried your code, and when Windows 95 on this PC  is using The large font setting, I get a Metrics.tmHeight value of 16. When it is using
The small font setting, I get a Metrics.tmHeight value of 13.
Will this always be the case, on all PC's, not depending on other
settings such as resolution e.g. 1024*768 in stead of 800 * 600, or other videodrivers?

I explain again what I what to do (simplified):

I display a window on the screen which always has a width of 600 pixels.
In this window is a label. The program reads the text to display on this
label and it fontsize from the commandline.
Suppose, I have a text to display which exactly fits into that window,
when I'm using the Use small fonts setting in Windows 95, only
a part will be visible when I'm using the Use large fonts settings.
(I do not want  use scrolling),

Therefore I need a function like this;

FontSizeFromCommandline (integer) is known, e.g. 14

FontSizeToUse:= CalculateFontSizeToUse(FontSizeFromCommandline);

CalculatieFontSizeToUse must do 2 things.

 1) Detect whether the Windows 95/NT setting of the fonts to use
    is Use Large Fonts or Use Small Fonts

 2a) When the setting is Use Small Fonts: return     FontSizeFromCommandline
    (in fact: do nothing, this value is already known).
 2b) When the setting is Use Large Fonts: calculate a fontsize,
    depending on FontSizeFromCommandline, such that exactly the
    same text will fit onto (the same line on) the window, as if the
    setting would be Use Small Fonts.

mosiAuthor Commented:
Adjusted points to 110
mosiAuthor Commented:
I accept your answer, although I guess I still have to
work out some things.
Question has a verified solution.

Are you are experiencing a similar issue? Get a personalized answer when you ask a related question.

Have a better answer? Share it in a comment.

All Courses

From novice to tech pro — start learning today.