How To Automatically Set The Font Size Relative To The Page Size

Solution

There are many ways to solve this problem, I have chosen to use standard System Printer and Page dialog with assigned one System Drawing Printing Print Document for obtaining all necessary printer data. There is also, System Font Dialog for collecting data about installed fonts. When program starts and Printer and Page dialog gets initialized, all printer necessary data are automatically set to Print Document. To access those data we can use Print Document Default Page Settings. After getting values for page printable area height and width, I have used Graphics Measure String method for finding out how many letters can fit across width and height. If Type Face of selected font is Non Proportional, this method gives accurate value for number of letters that can fit across page width. If selected Font Typeface is Proportional then, it is necessary to know exactly what text is going to be printed in a single line on the page, and then to use Graphics Measure String method to find out if a line of text can fit on page and change font size accordingly. Number of letters that can fit across page height do not depends on Font Type Face Proportion, and is always accurate when we use Graphics Measure String method.

Here is simple Page_Size_In_Letters method that accepts two parameters Print Document and Font Type. Method returns Tuple, Page Size In Chars with three item values, Page Width, Page Height and Type Face Monospaced Proportion. If Selected Font Type Face is Proportional, the value of Page Width is -1, otherwise it is accurately calculated. Notice that measurement unit for Page Size, Font Size, and Graphics used for calculation is set Pixel.

/// <summary>
/// Calculates size of page in characters
/// using SizeF Graphics.MeasureString() method
/// </summary>
/// <param name="Print_Document"></param>
/// <param name="Font_Type"></param>
/// <returns>
/// Triple, Page Width, Page Height and
/// Font Type Face Monospaced true or false value.
/// </returns>
Tuple<int, int, bool> Page_Size_In_Letters(PrintDocument Print_Document, Font Font_Type)
{
    // Printer Hard Margins
    float Hard_Margin_X = 0F;
    float Hard_Margin_Y = 0F;

    // Page Margins
    float Top_Margin = 0F;
    float Bottom_Margin = 0F;
    float Left_Margin = 0F;
    float Right_Margin = 0F;

    // Phisycal Page Size
    float Page_Height = 0F;
    float Page_Width = 0F;

    // Set Value to Printer Hard Margins
    Hard_Margin_X = Print_Document.DefaultPageSettings.HardMarginX;
    Hard_Margin_Y = Print_Document.DefaultPageSettings.HardMarginY;

    // Set Value to Page Margins
    Top_Margin = Print_Document.DefaultPageSettings.Margins.Top;
    Bottom_Margin = Print_Document.DefaultPageSettings.Margins.Bottom;
    Left_Margin = Print_Document.DefaultPageSettings.Margins.Left;
    Right_Margin = Print_Document.DefaultPageSettings.Margins.Right;

    // Compare Values Of Page Margins Set By User
    // with Printer Hard Margins
    if (Top_Margin < Hard_Margin_Y)
        Top_Margin = Hard_Margin_Y;
    if (Bottom_Margin < Hard_Margin_Y)
        Bottom_Margin = Hard_Margin_Y;

    if (Left_Margin < Hard_Margin_X)
        Left_Margin = Hard_Margin_X;
    if (Right_Margin < Hard_Margin_X)
        Right_Margin = Hard_Margin_X;

    // Set Values of Page Size accordingly to Page Orientation
    Page_Height = Print_Document.DefaultPageSettings.Bounds.Height;
    Page_Width = Print_Document.DefaultPageSettings.Bounds.Width;

    // Calculate Page Printable Area Size Height and Width
    Page_Height = Page_Height - Top_Margin - Bottom_Margin;
    Page_Width = Page_Width - Left_Margin - Right_Margin;

    // Recalculate Size from Hundreds of an Inch to Pixel
    Page_Height = Page_Height * (DeviceDpi / 100F);
    Page_Width = Page_Width * (DeviceDpi / 100F);

    // Set New Font Type with size in Pixel and
    // with measurement unit Pixel
    Font_Type = new Font(
        Font_Type.FontFamily,
        Font_Type.SizeInPoints / (72F / (float)DeviceDpi), // Points to Pixel
        Font_Type.Style,
        GraphicsUnit.Pixel,
        Font_Type.GdiCharSet);

    // Set new Graphics with measurement unit Pixel
    Graphics G = Graphics.FromImage(new Bitmap(1, 1));
    G.Clear(Color.White);
    G.SmoothingMode = SmoothingMode.HighQuality;
    G.InterpolationMode = InterpolationMode.HighQualityBicubic;
    G.PixelOffsetMode = PixelOffsetMode.HighQuality;

    G.PageUnit = GraphicsUnit.Pixel; // Measurement unit Pixel

    // Check Font Type Face

    // Smallest character
    string Word_1 = ".";
    SizeF Measured_Length_Of_Word_1 = new SizeF();
    Measured_Length_Of_Word_1 = G.MeasureString(Word_1, Font_Type, 0, StringFormat.GenericTypographic);

    // Widest character
    string Word_2 = "W";
    SizeF Measured_Length_Of_Word_2 = new SizeF();
    Measured_Length_Of_Word_2 = G.MeasureString(Word_2, Font_Type, 0, StringFormat.GenericTypographic);

    // If measured Width of characters is equal, font is Monocpaced
    bool Monospaced = (Measured_Length_Of_Word_1.Width == Measured_Length_Of_Word_2.Width);

    // Calculate how many letters can fit across
    // printable page area width for selected font type
    int Number_Of_letters_In_Row = 0;
    string Word = "";
    SizeF Measured_Length_Of_Word = new SizeF();
    while (Measured_Length_Of_Word.Width <= Page_Width)
    {
        Number_Of_letters_In_Row++;
        Word += "W";
        Measured_Length_Of_Word = G.MeasureString(Word, Font_Type, 0, StringFormat.GenericTypographic);
    }

    Number_Of_letters_In_Row--;

    // Calculate how many letters can fit across
    // printable page area height for selected font type
    int Number_Of_Letters_In_Column = 0;
    Word = "";
    Measured_Length_Of_Word = new SizeF();
    while (Measured_Length_Of_Word.Height <= Page_Height)
    {
        Number_Of_Letters_In_Column++;
        Word += Environment.NewLine;
        Measured_Length_Of_Word = G.MeasureString(Word, Font_Type, 0, StringFormat.GenericTypographic);
    }

    Number_Of_Letters_In_Column--;

    // If Type Face is Proportional set Width of page to -1
    if(!Monospaced)
        Number_Of_letters_In_Row = -1;

    Tuple<int, int, bool> Page_Size_In_Chars =
            new Tuple<int, int, bool>(
                        Number_Of_letters_In_Row,
                        Number_Of_Letters_In_Column,
                        Monospaced);

    // Return Page Size in Characters
    return Page_Size_In_Chars;
}

This method can be used in a loop to automatically find out, and set, size of font that allows us to fit multiple lines of text across printing page area.

At the beginning of this article, there is an open source solution created in Visual Studio 2022, .Net Framework 4.8. Download it and thoroughly analyze program code.

All the best,