Merge pull request #2341 from matt335672/scaled_login_screen

Scaled login screen support
2022-09-06 09:48:09 +01:00 · 2022-09-06 09:48:09 +01:00 · 7354eb6060
parent c3585adaa0 e44879740f
commit 7354eb6060
30 changed files with 2390 additions and 237 deletions
--- a/Makefile.am
+++ b/Makefile.am
@ -11,7 +11,6 @@ EXTRA_DIST = \
  astyle_config.as \
  bootstrap \
  coding_style.md \
-  fontdump \
  m4 \
  vrplayer

@ -57,6 +56,7 @@ SUBDIRS = \
  $(RFXCODECDIR) \
  sesman \
  xrdp \
+  fontutils \
  keygen \
  docs \
  instfiles \
--- a/README.md
+++ b/README.md
@ -124,7 +124,7 @@ pulseaudio modules. The build instructions can be found at wiki.
 xrdp
 ├── common ······ common code
 ├── docs ········ documentation
-├── fontdump ···· font dump for Windows
+├── fontutils ··· font handling utilities
 ├── genkeymap ··· keymap generator
 ├── instfiles ··· installable data file
 ├── keygen ······ xrdp RSA key pair generator
--- a/common/defines.h
+++ b/common/defines.h
@ -91,8 +91,10 @@
        b = (c) & 0xff; \
    }
 /* font macros */
-#define FONT_DATASIZE(f) \
-    ((((f)->height * (((f)->width + 7) / 8)) + 3) & ~3);
+#define FONT_DATASIZE_FROM_GEOMETRY(width,height) \
+    ((((height) * (((width) + 7) / 8)) + 3) & ~3)
+#define FONT_DATASIZE(f) FONT_DATASIZE_FROM_GEOMETRY((f->width), (f->height))
+
 /* use crc for bitmap cache lookups */
 #define USE_CRC

--- a/common/os_calls.c
+++ b/common/os_calls.c
@ -343,6 +343,13 @@ g_memcpy(void *d_ptr, const void *s_ptr, int size)
    memcpy(d_ptr, s_ptr, size);
 }

+/*****************************************************************************/
+void
+g_memmove(void *d_ptr, const void *s_ptr, int size)
+{
+    memmove(d_ptr, s_ptr, size);
+}
+
 /*****************************************************************************/
 int
 g_getchar(void)
--- a/common/os_calls.h
+++ b/common/os_calls.h
@ -62,6 +62,7 @@ void g_write(const char *format, ...) printflike(1, 2);
 void     g_hexdump(const char *p, int len);
 void     g_memset(void *ptr, int val, int size);
 void     g_memcpy(void *d_ptr, const void *s_ptr, int size);
+void     g_memmove(void *d_ptr, const void *s_ptr, int size);
 int      g_getchar(void);
 int      g_tcp_set_no_delay(int sck);
 int      g_tcp_set_keepalive(int sck);
--- a/configure.ac
+++ b/configure.ac
@ -190,6 +190,8 @@ AM_CONDITIONAL(XRDP_RDPSNDAUDIN, [test x$enable_rdpsndaudin = xyes])

 AC_ARG_WITH(imlib2, AC_HELP_STRING([--with-imlib2=ARG], [imlib2 library to use for non-BMP backgrounds (ARG=yes/no/<abs-path>)]),,)

+AC_ARG_WITH(freetype2, AC_HELP_STRING([--with-freetype2=ARG], [freetype2 library to use for rendering fonts (ARG=yes/no/<abs-path>)]),,)
+
 # Obsolete options
 AC_ARG_ENABLE(xrdpdebug, AS_HELP_STRING([--enable-xrdpdebug],
              [This option is no longer supported - use --enable-devel-all]))
@ -278,6 +280,41 @@ if test x$use_imlib2 = xyes; then
    AC_DEFINE([USE_IMLIB2],1, [Compile with imlib2 support])
 fi

+# Find freetype2
+case "$with_freetype2" in
+    '' | no) AC_MSG_NOTICE([freetype2 will not be supported])
+        use_freetype2=no
+        ;;
+    yes)
+        PKG_CHECK_MODULES([FREETYPE2], [freetype2 >= 2.8],
+            [use_freetype2=yes],
+            [AC_MSG_ERROR([please install libfreetype6-dev or freetype-devel])])
+        ;;
+    /*) AC_MSG_CHECKING([for freetype2 in $with_freetype2])
+        if test -d $with_freetype2/lib; then
+            FREETYPE2_LIBS="-L$with_freetype2/lib -llibfreetype"
+        elif test -d $with_freetype2/lib64; then
+            FREETYPE2_LIBS="-L$with_freetype2/lib64 -llibfreetype"
+        else
+            AC_MSG_RESULT([no])
+            AC_MSG_ERROR([Can't find libfreetype in $with_freetype2])
+        fi
+
+        if test -f $with_freetype2/include/freetype2/ft2build.h; then
+            FREETYPE2_CFLAGS="-I $with_freetype2/include/freetype2"
+        else
+            AC_MSG_RESULT([no])
+            AC_MSG_ERROR([Can't find $with_freetype2/include/freetype2/ft2build.h])
+        fi
+        AC_MSG_RESULT([yes])
+        AC_SUBST([FREETYPE2_LIBS])
+        AC_SUBST([FREETYPE2_CFLAGS])
+        use_freetype2=yes
+        ;;
+    *)  AC_MSG_ERROR([--with-freetype2 needs yes/no or absolute path])
+esac
+AM_CONDITIONAL([USE_FREETYPE2], [test "x$use_freetype2" = xyes])
+
 # Check only one auth mechanism is specified, and give it a name
 auth_cnt=0
 auth_mech="Builtin"
@ -494,6 +531,7 @@ AC_CONFIG_FILES([
  common/Makefile
  docs/Makefile
  docs/man/Makefile
+  fontutils/Makefile
  genkeymap/Makefile
  instfiles/default/Makefile
  instfiles/init.d/Makefile
@ -551,11 +589,9 @@ echo "  vsock                   $enable_vsock"
 echo "  auth mechanism          $auth_mech"
 echo "  rdpsndaudin             $enable_rdpsndaudin"
 echo
-if test x$use_imlib2 = xyes; then
-    echo "  with imlib2             yes"
-else
-    echo "  with imlib2             no"
-fi
+echo "  with imlib2             $use_imlib2"
+echo "  with freetype2          $use_freetype2"
+
 echo
 echo "  development logging     $devel_logging"
 echo "  development streamcheck $devel_streamcheck"
--- a/docs/man/Makefile.am
+++ b/docs/man/Makefile.am
@ -1,3 +1,9 @@
+if USE_FREETYPE2
+  MKFV1_MAN = xrdp-mkfv1.8
+else
+  MKFV1_MAN =
+endif
+
 man_MANS = \
  xrdp-dis.1 \
  sesman.ini.5 \
@ -8,7 +14,9 @@ man_MANS = \
  xrdp-keygen.8 \
  xrdp-sesadmin.8 \
  xrdp-sesman.8 \
-  xrdp-sesrun.8
+  xrdp-sesrun.8 \
+  xrdp-dumpfv1.8 \
+  $(MKFV1_MAN)

 EXTRA_DIST = $(man_MANS:=.in)

@ -21,6 +29,7 @@ SUBST_VARS = sed \
   -e 's|@socketdir[@]|$(socketdir)|g' \
   -e 's|@sesmanruntimedir[@]|$(sesmanruntimedir)|g' \
   -e 's|@xrdpconfdir[@]|$(sysconfdir)/xrdp|g' \
+   -e 's|@xrdpdatadir[@]|$(datadir)/xrdp|g' \
   -e 's|@xrdphomeurl[@]|http://www.xrdp.org/|g'

 subst_verbose = $(subst_verbose_@AM_V@)
--- a/docs/man/xrdp-dumpfv1.8.in
+++ b/docs/man/xrdp-dumpfv1.8.in
@ -0,0 +1,58 @@
+.TH "xrdp-dumpfv1" "8" "@PACKAGE_VERSION@" "xrdp team"
+.SH NAME
+xrdp\-dumpfv1 \- Display content of .fv1 font files
+
+.SH SYNOPSIS
+\fBxrdp-dumpfv1\fR [ options ] fv1_file
+
+.SH DESCRIPTION
+\fBxrdp\-dumpfv1\fP can be used to display the contents of an fv1 file.
+
+.SH OPTIONS
+A summary of options is included below.
+
+One of \fB\-i\fR, \fB\-t\fR, or \fB\-c\fR must be specified.
+.TP
+\fB\-i\fR
+Displays general information about the fv1 file.
+
+.TP
+\fB\-t\fR
+Displays a CSV table of all the glyphs in the font. This table can be
+imported into a spreadsheet program for further manipulation.
+
+.TP
+\fB\-c\fR <character>
+Displays detailed information about a particular glyph in the font,
+including a representation of the bitmap for the glyph.
+
+Specify the character using one of the following strings:
+
+\fBU+<hex>\fR - Unicode character, e.g. \fBU+25\fR for a percentage symbol (%).
+
+\fB@<char>\fR - Unicode character, e.g. \fB@%\fR for a percentage symbol.
+
+\fBnumber\fR - Unicode value as an integer, e.g. \fB37\fR for a
+percentage symbol
+
+Note that the row numbers shown in the font data are relative to the
+natural font baseline. If comparing two fonts, be aware that when the
+glyph is drawn, the row number may be affected by the global descender
+value for the font (displayed with \fB\-i\fR).
+
+.SH "EXAMPLES"
+.TP
+\fBxrdp\-dumpfv1 -i @xrdpdatadir@/sans-10.fv1\fR
+Displays global information about the sans 10 font file distributed with xrdp.
+
+.TP
+\fBxrdp\-dumpfv1 -c @'*' @xrdpdatadir@/sans-10.fv1\fR
+Displays information about the asterisk symbol in the sans 10 font file distributed with xrdp.
+
+.SH SEE ALSO
+.BR xrdp\-mkfv1(8).
+
+More info on \fBxrdp\fR can be found on the
+.UR @xrdphomeurl@
+xrdp homepage
+.UE
--- a/docs/man/xrdp-mkfv1.8.in
+++ b/docs/man/xrdp-mkfv1.8.in
@ -0,0 +1,81 @@
+.TH "xrdp-mkfv1" "8" "@PACKAGE_VERSION@" "xrdp team"
+.SH NAME
+xrdp\-mkfv1 \- Create .fv1 font files from other font files
+
+.SH SYNOPSIS
+\fBxrdp-mkfv1\fR [ options ] font_file fv1_file
+
+.SH DESCRIPTION
+\fBxrdp\-mkfv1\fP can be used to convert a font file such as a TrueType
+font to a fv1 file.
+
+.SH OPTIONS
+A summary of options is included below.
+
+.TP
+\fB\-n\fR <font_name>
+Give the font a name, which is stored in the font header.
+
+The default is to use the font family name from the source font.
+
+.TP
+\fB\-p\fR <number>
+Set the point size of the font. A fixed DPI value of 96 is used for
+converting this value into a pixel size.
+
+The default value for this option is '10'.
+
+.TP
+\fB\-m\fR <glyph>
+Set the limit on the glyphs stored in the font file. The argument is the last
+glyph stored in the font file.
+
+Specify the glyph using one of the following strings:
+
+\fBU+<hex>\fR - Unicode character, e.g. \fBU+25\fR for a percentage symbol (%).
+
+\fB@<char>\fR - Unicode character, e.g. \fB@%\fR for a percentage symbol.
+
+\fBnumber\fR - Unicode value as an integer, e.g. \fB37\fR for a
+percentage symbol
+
+The default value for this option is 'U+4DFF'.
+
+.TP
+\fB\-C\fR
+When used with the "DejaVu Sans" font at a point-size of 10, a small
+number of glyphs are assigned a different x-offset than they have
+when the original Windows font generation program is used.
+
+This switch can be used to preserve the original x-offsets for glyphs in
+the range U+0020 - U+00FF when a 10 point DajaVu Sans font is generated.
+
+Use one of the following arguments to this option:-
+
+\fBauto\fR - Automatic mode. Offsets are preserved if a "DajaVu Sans" 10-point font is converted.
+
+\fBon / true / yes\fR - Preserve offsets if automatic font detection does not work.
+
+\fBoff / false / no\fR - Do not tamper with the offsets generated by the program.
+
+The default value of this switch is \fRauto\fR.
+
+To see the effects of this switch, set the \fBMKFV1_LOG_LEVEL\fR environment
+variable to \fBinfo\fR before running the program.
+
+.SH "EXAMPLES"
+.TP
+\fBxrdp-mkfv1 -p18 /path/to/DejaVuSans.ttf ./sans-18.fv1\fR
+Generate an 18-point Deja Sans font.
+
+.TP
+\fBxrdp-mkfv1 -C off -p10 /path/to/DejaVuSans.ttf ./sans-10.fv1\fR
+Generate a 10-point DajaVu Sans font using natural offsets.
+
+.SH SEE ALSO
+.BR xrdp\-dumpfv1(8).
+
+More info on \fBxrdp\fR can be found on the
+.UR @xrdphomeurl@
+xrdp homepage
+.UE
--- a/docs/man/xrdp.ini.5.in
+++ b/docs/man/xrdp.ini.5.in
@ -125,12 +125,12 @@ separator as the password supplied by the user and treats it as autologon. If no
 defaults to \fBfalse\fP.

 .TP
-\domain_user_separator\fP=\separator\fP
+\fBdomain_user_separator\fP=\fBseparator\fP
 If specified the domain name supplied by the client is appended to the username separated
 by \fBseparator\fP.

 .TP
-\enable_token_login\fP=\fI[true|false]\fP
+\fBenable_token_login\fP=\fI[true|false]\fP
 If set to \fB1\fP, \fBtrue\fP or \fByes\fP, \fBxrdp\fP requires clients to include username and
 password initial connection phase. In other words, xrdp doesn't allow clients to show login
 screen if set to true. If not specified, defaults to \fBfalse\fP.
@ -212,6 +212,18 @@ These options override the colors used internally by \fBxrdp\fP(8) to draw the l
 Colors are defined using a hexadecimal (hex) notation for the combination of Red, Green, and Blue color values (RGB).
 The lowest value that can be given to one of the light sources is 0 (hex 00).
 The highest value is 255 (hex FF).
+.TP
+\fBfv1_select\fP=\fI130:sans-18.fv1,0:sans-10.fv1\fP
+Selects a default fv1 font.
+This parameter is a comma-separated list of DPI:name pairs.  The list
+is scanned from left-to-right. The font used is the first font whose DPI
+value is less-than-or-equal to the vertical DPI of the monitor used for
+the login screen.
+.TP
+\fBdefault_dpi\fP=\fI96\fP
+Default DPI used for a monitor if the client does not send physical
+size information.
+

 .SH "LOGGING"
 The following parameters can be used in the \fB[Logging]\fR section:
--- a/fontutils/Makefile.am
+++ b/fontutils/Makefile.am
@ -0,0 +1,34 @@
+EXTRA_DIST = windows
+
+# Some programs need freetype2 to build
+if USE_FREETYPE2
+  MKFV1 = xrdp-mkfv1
+else
+  MKFV1 =
+endif
+
+AM_CPPFLAGS =  \
+  -I$(top_builddir) \
+  -I$(top_srcdir)/common \
+  $(FREETYPE2_CFLAGS)
+
+bin_PROGRAMS = \
+  $(MKFV1) \
+  xrdp-dumpfv1
+
+xrdp_mkfv1_SOURCES = \
+  mkfv1.c \
+  fv1.c \
+  fv1.h
+
+xrdp_mkfv1_LDADD = \
+  $(top_builddir)/common/libcommon.la \
+  $(FREETYPE2_LIBS)
+
+xrdp_dumpfv1_SOURCES = \
+  dumpfv1.c \
+  fv1.c \
+  fv1.h
+
+xrdp_dumpfv1_LDADD = \
+  $(top_builddir)/common/libcommon.la
--- a/fontutils/README_fv1.txt
+++ b/fontutils/README_fv1.txt
@ -0,0 +1,87 @@
+The fv1 font format has the following characteristics:-
+
+1) Bitmap fonts (i.e. pixels are on or off)
+2) 96 DPI is assumed
+3) Glyphs from U+0020 up to a pre-defined limit are stored in the file.
+   At the time of writing this limit is U+4DFF. To change the limit
+   requires a change to xrdp/xrdp_types.h and (potentially)
+   fontutils/mkfv1.c
+4) Font format is header, plus a variable data area for each glyph.
+
+The intention (over time) is to build support for the freetype2 library
+directly into xrdp. This will allow for modern font features like
+anti-aliasing and kerning to be supported.
+
+General Info
+------------
+All numeric values are 2 octets, and stored in twos-complement
+little-endian format.
+
+Dimensions are all measured in pixels.
+
+Font header
+-----------
+
+signature     4 octets   File signature - "FNT1"
+font~name    32 octets   Null-terminated if less that 32 octets long
+point_size    2 octets   Assumes 96 DPI.
+style         2 octets   Unused. Set to 1.
+body_height   2 octets   Line spacing for font.
+min_descender 2 octets   The common lowest descender value in the font
+                         glyphs (A few glyphs may be lower than
+                         this). Used to calculate where the font baseline
+                         is in relation to the text box for the font.
+<padding>     4 octets   Set to zero.
+
+Older fonts, generated for xrdp v.0.9x and earlier, have zero values
+for the body_height and min_descender. For these fonts, the body height is
+calculated as (-baseline + 1) for the first glyph, and the glyphs are
+all offset so that a min_descender of 0 works OK.
+
+Glyph data
+----------
+The header is followed by a number of glyphs representing U+0020 upwards. The
+glyphs have a variable size. The format of each glyph is as follows:-
+
+width         2 octets   Width of character data
+height        2 octets   Height of character data
+baseline      2 octets   Offset from font baseline to 1st row of glyph data
+offset        2 octets   Space before glyph is drawn (can be -ve)
+inc_by        2 octets   Total width of glyph + spacing. The width of
+                         a string is obtained by adding up all the inc_by
+                         fields for all the glyphs
+data          <variable> Bitmap data.
+
+Bitmap data is laid out in rows from top to bottom.  Within each row the
+most significant bit of each octet is on the left.  Row data is padded
+to the nearest octet (e.g. a 14 bit width would be padded by 2 bits to
+16 bits (2 octets). The total data is padded out with between 0 and 3
+octets to end on a 4-octet boundary.
+
+Example glyph:-
+
+Glyph : U+0067
+  Width : 12
+  Height : 18
+  Baseline : -13
+  Offset : 1
+  Inc By : 15
+  Data :
+    -13: ...XXXXX..XX    1F 30
+    -12: ..XXXXXXXXXX    3F F0
+    -11: .XXX....XXXX    70 F0
+    -10: XXX......XXX    E0 70
+     -9: XX........XX    C0 30
+     -8: XX........XX    C0 30
+     -7: XX........XX    C0 30
+     -6: XX........XX    C0 30
+     -5: XX........XX    C0 30
+     -4: XXX......XXX    E0 70
+     -3: .XXX....XXXX    70 F0
+     -2: ..XXXXXXXXXX    3F F0
+     -1: ...XXXXX..XX    1F 30
+     +0: ..........XX    00 30
+     +1: .........XXX    00 70
+     +2: ..X.....XXX.    20 E0
+     +3: ..XXXXXXXX..    3F C0
+     +4: ...XXXXXX...    1F 80
--- a/fontutils/dumpfv1.c
+++ b/fontutils/dumpfv1.c
@ -0,0 +1,413 @@
+/**
+ * xrdp: A Remote Desktop Protocol server.
+ *
+ * Copyright (C) Jay Sorg 2004-2022
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ * fonts
+ */
+
+#if defined(HAVE_CONFIG_H)
+#include <config_ac.h>
+#endif
+
+#include <limits.h>
+#include <unistd.h>
+#include <ctype.h>
+
+#include "list.h"
+#include "os_calls.h"
+#include "parse.h"
+#include "string_calls.h"
+#include "fv1.h"
+
+/**
+ * What the program is doing
+ */
+enum program_mode
+{
+    PM_UNSPECIFIED = 0,
+    PM_INFO,
+    PM_GLYPH_INFO_TABLE,
+    PM_SHOW_CHAR
+};
+
+/**
+ * Parsed program arguments
+ */
+struct program_args
+{
+    const char *font_file;
+    enum program_mode mode;
+    int ucode; /* Unicode character to display in 'c' mode */
+};
+
+/**************************************************************************//**
+ * Parses the program args
+ *
+ * @param argc Passed to main
+ * @param @argv Passed to main
+ * @param pa program_pargs structure for resulting values
+ * @return !=0 for success
+ */
+static int
+parse_program_args(int argc, char *argv[], struct program_args *pa)
+{
+    int params_ok = 1;
+    int opt;
+
+    pa->font_file = NULL;
+    pa->mode = PM_UNSPECIFIED;
+    pa->ucode = 0;
+
+    while ((opt = getopt(argc, argv, "c:it")) != -1)
+    {
+        switch (opt)
+        {
+            case 'i':
+                if (pa->mode == PM_UNSPECIFIED)
+                {
+                    pa->mode = PM_INFO;
+                }
+                else
+                {
+                    LOG(LOG_LEVEL_ERROR, "Can't have two modes set");
+                    params_ok = 0;
+                }
+                break;
+
+            case 't':
+                if (pa->mode == PM_UNSPECIFIED)
+                {
+                    pa->mode = PM_GLYPH_INFO_TABLE;
+                }
+                else
+                {
+                    LOG(LOG_LEVEL_ERROR, "Can't have two modes set");
+                    params_ok = 0;
+                }
+                break;
+
+            case 'c':
+                if (pa->mode == PM_UNSPECIFIED)
+                {
+                    pa->mode = PM_SHOW_CHAR;
+                    if (toupper(optarg[0]) == 'U' && optarg[1] == '+')
+                    {
+                        char *hex = g_strdup(optarg);
+                        hex[0] = '0';
+                        hex[1] = 'x';
+                        pa->ucode = g_atoix(hex);
+                        g_free(hex);
+                    }
+                    else if (optarg[0] == '@')
+                    {
+                        pa->ucode = optarg[1];
+                    }
+                    else
+                    {
+                        pa->ucode = g_atoix(optarg);
+                    }
+                }
+                else
+                {
+                    LOG(LOG_LEVEL_ERROR, "Can't have two modes set");
+                    params_ok = 0;
+                }
+                break;
+
+            default:
+                LOG(LOG_LEVEL_ERROR, "Unrecognised switch '%c'", (char)opt);
+                params_ok = 0;
+        }
+    }
+
+    if (argc <= optind)
+    {
+        LOG(LOG_LEVEL_ERROR, "No font file specified");
+        params_ok = 0;
+    }
+    else if ((argc - optind) > 1)
+    {
+        LOG(LOG_LEVEL_ERROR, "Unexpected arguments after font file");
+        params_ok = 0;
+    }
+    else
+    {
+        pa->font_file = argv[optind];
+    }
+
+    return params_ok;
+}
+
+/**************************************************************************//**
+ * Displays information about a font file
+ *
+ * @param fv1 loaded font file
+ */
+static void
+display_font_file_info(const struct fv1_file *fv1)
+{
+    g_printf("Font name : %s\n", fv1->font_name);
+    g_printf("Point size (%d DPI) : %d\n", FV1_DEVICE_DPI, fv1->point_size);
+    g_printf("Style : %d\n", fv1->style);
+    if (fv1->body_height == 0 && fv1->glyphs->count > 0)
+    {
+        const struct fv1_glyph *g =
+            (const struct fv1_glyph *)fv1->glyphs->items[0];
+        g_printf("Body height : %d (from 1st glyph)\n", -g->baseline + 1);
+    }
+    else
+    {
+        g_printf("Body height : %d\n", fv1->body_height);
+    }
+    g_printf("Descender : %d\n", fv1->min_descender);
+
+    if (fv1->glyphs->count == 0)
+    {
+        g_printf("\nFile contains no glyphs\n");
+    }
+    else
+    {
+        g_printf("Min glyph index : U+%04X\n", FV1_MIN_CHAR);
+        g_printf("Max glyph index : U+%04X\n", FV1_GLYPH_END(fv1) - 1);
+
+        /* Work out the statistics */
+        unsigned short max_width = 0;
+        int max_width_ucode = 0;
+        unsigned short max_height = 0;
+        int max_height_ucode = 0;
+        short min_baseline = 0;
+        int min_baseline_ucode = 0;
+        short min_offset = 0;
+        int min_offset_ucode = 0;
+        short max_offset = 0;
+        int max_offset_ucode = 0;
+        unsigned short max_inc_by = 0;
+        int max_inc_by_ucode = 0;
+
+        /* Derived quantities */
+        short min_y_descender = SHRT_MAX;
+        int min_y_descender_ucode = 0;
+        int max_datasize = -1;
+        int max_datasize_ucode = 0;
+
+        /* Loop and output macros */
+#define SET_MIN(ucode,field,val) \
+    if ((field) < (val)) \
+    { \
+        val = (field); \
+        val##_ucode = (ucode); \
+    }
+
+#define SET_MAX(ucode,field,val) \
+    if ((field) > (val)) \
+    { \
+        val = (field); \
+        val##_ucode = (ucode); \
+    }
+
+#define OUTPUT_INFO(string, val) \
+    if (val##_ucode > 0) \
+    { \
+        g_printf(string, val, val##_ucode); \
+    }
+        int u;
+        for (u = FV1_MIN_CHAR ; u < FV1_GLYPH_END(fv1); ++u)
+        {
+            const struct fv1_glyph *g = FV1_GET_GLYPH(fv1, u);
+            if (g != NULL)
+            {
+                short y_descender = - (g->baseline + g->height);
+                int datasize = FONT_DATASIZE(g);
+
+                SET_MAX(u, g->width, max_width);
+                SET_MAX(u, g->height, max_height);
+                SET_MIN(u, g->baseline, min_baseline);
+                SET_MIN(u, g->offset, min_offset);
+                SET_MAX(u, g->offset, max_offset);
+                SET_MAX(u, g->inc_by, max_inc_by);
+                SET_MIN(u, y_descender, min_y_descender);
+                SET_MAX(u, datasize, max_datasize);
+            }
+        }
+
+        OUTPUT_INFO("Max glyph width : %d (U+%04X)\n", max_width);
+        OUTPUT_INFO("Max glyph height : %d (U+%04X)\n", max_height);
+        OUTPUT_INFO("Min glyph y-baseline : %d (U+%04X)\n", min_baseline);
+        OUTPUT_INFO("Min glyph y-descender : %d (U+%04X)\n", min_y_descender);
+        OUTPUT_INFO("Min glyph x-offset : %d (U+%04X)\n", min_offset);
+        OUTPUT_INFO("Max glyph x-offset : %d (U+%04X)\n", max_offset);
+        OUTPUT_INFO("Max glyph x-inc_by : %d (U+%04X)\n", max_inc_by);
+        OUTPUT_INFO("Max glyph datasize : %d (U+%04X)\n", max_datasize);
+
+#undef SET_MIN
+#undef SET_MAX
+#undef OUTPUT_INFO
+    }
+}
+
+/**************************************************************************//**
+ * Display info in a table about all the glyphs
+ * @param fv1 font file
+ */
+static void
+display_glyph_info_table(const struct fv1_file *fv1)
+{
+    int u;
+    g_printf("character,width,height,baseline,offset,inc_by,datasize\n");
+
+    for (u = FV1_MIN_CHAR; u < FV1_GLYPH_END(fv1); ++u)
+    {
+        const struct fv1_glyph *g = FV1_GET_GLYPH(fv1, u);
+        if (g != NULL)
+        {
+            int datasize = FONT_DATASIZE(g);
+            g_printf("%d,%hu,%hu,%hd,%hd,%hu,%d\n",
+                     u, g->width, g->height, g->baseline,
+                     g->offset, g->inc_by, datasize);
+        }
+    }
+}
+
+/**************************************************************************//**
+ * Converts a font data row to a printable string
+ *
+ * @param rowdata Pointer to the first byte of the row data
+ * @param width Number of pixels in the row
+ * @param out Output buffer. Must be sized by the caller to be at
+ *            least width+1 bytes
+ */
+static void
+row_to_str(const unsigned char *rowdata, int width, char *out)
+{
+    int x;
+    int mask = 1 << 7;
+    for (x = 0 ; x < width ; ++x)
+    {
+        out[x] = ((*rowdata & mask) != 0) ? 'X' : '.';
+        mask >>= 1;
+        if (mask == 0)
+        {
+            mask = 1 << 7;
+            ++rowdata;
+        }
+    }
+    out[width] = '\0';
+}
+
+/**************************************************************************//**
+ * Display info about a specific glyph
+ * @param ucode Unicode character value
+ * @param g Glyph
+ */
+static void
+display_glyph_info(int ucode, const struct fv1_glyph *g)
+{
+
+    char *row_buffer = (char *)g_malloc(g->width + 1, 0);
+    if (row_buffer == NULL)
+    {
+        g_printf("<No memory>\n");
+    }
+    else
+    {
+        g_printf("Glyph : U+%04X\n", ucode);
+        g_printf("  Width : %d\n", g->width);
+        g_printf("  Height : %d\n", g->height);
+        g_printf("  Baseline : %d\n", g->baseline);
+        g_printf("  Offset : %d\n", g->offset);
+        g_printf("  Inc By : %d\n", g->inc_by);
+
+        g_printf("  Data :\n");
+        int y;
+        const unsigned char *dataptr = g->data;
+
+        for (y = 0 ; y < g->height; ++y)
+        {
+            row_to_str(dataptr, g->width, row_buffer);
+            g_printf("    %+3d: %s\n", y + g->baseline, row_buffer);
+            dataptr += (g->width + 7) / 8;
+        }
+        g_free(row_buffer);
+    }
+}
+
+/**************************************************************************//**
+ * Main
+ *
+ * @param argc Argument count
+ * @param argv Arguments
+ */
+int
+main(int argc, char *argv[])
+{
+    struct fv1_file *fv1 = NULL;
+    struct log_config *logging;
+    struct program_args pa;
+    int rv = 1;
+
+    logging = log_config_init_for_console(LOG_LEVEL_WARNING,
+                                          g_getenv("DUMPFV1_LOG_LEVEL"));
+    log_start_from_param(logging);
+    log_config_free(logging);
+
+    if (parse_program_args(argc, argv, &pa) &&
+            (fv1 = fv1_file_load(pa.font_file)) != NULL)
+    {
+        switch (pa.mode)
+        {
+            case PM_INFO:
+                display_font_file_info(fv1);
+                rv = 0;
+                break;
+
+            case PM_GLYPH_INFO_TABLE:
+                display_glyph_info_table(fv1);
+                rv = 0;
+                break;
+
+            case PM_SHOW_CHAR:
+                if (pa.ucode < FV1_MIN_CHAR)
+                {
+                    LOG(LOG_LEVEL_ERROR, "Value for -c must be at least U+%04X",
+                        FV1_MIN_CHAR);
+                }
+                else if (pa.ucode >= FV1_GLYPH_END(fv1))
+                {
+                    LOG(LOG_LEVEL_ERROR,
+                        "Value for -c must be less than U+%04X",
+                        FV1_GLYPH_END(fv1));
+                }
+                else
+                {
+                    const struct fv1_glyph *g =
+                        (const struct fv1_glyph *)
+                        list_get_item(fv1->glyphs, pa.ucode - FV1_MIN_CHAR);
+                    display_glyph_info(pa.ucode, g);
+                    rv = 0;
+                }
+                break;
+
+            default:
+                LOG(LOG_LEVEL_ERROR, "Specify one of '-i' or '-c'");
+                break;
+        }
+    }
+
+    fv1_file_free(fv1);
+    log_end();
+
+    return rv;
+}
--- a/fontutils/fv1.c
+++ b/fontutils/fv1.c
@ -0,0 +1,352 @@
+/**
+ * xrdp: A Remote Desktop Protocol server.
+ *
+ * Copyright (C) Jay Sorg 2004-2022
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file    fontutils/fv1.c
+ * @brief   Definitions relating to fv1 font files
+ */
+#if defined(HAVE_CONFIG_H)
+#include <config_ac.h>
+#endif
+
+#include <stdio.h>
+#include <stddef.h>
+
+#include "list.h"
+#include "os_calls.h"
+#include "parse.h"
+#include "string_calls.h"
+#include "fv1.h"
+
+const static char FV1_SIGNATURE[] = {'F', 'N', 'T', '1'};
+
+/*****************************************************************************/
+struct fv1_glyph *
+fv1_alloc_glyph(int ucode,
+                unsigned short width,
+                unsigned short height)
+{
+    int datasize = FONT_DATASIZE_FROM_GEOMETRY(width, height);
+    struct fv1_glyph *glyph = NULL;
+    char ucode_str[16] = {'\0'};
+    if (ucode < 0)
+    {
+        g_snprintf(ucode_str, sizeof(ucode_str), "Glyph");
+    }
+    else
+    {
+        g_snprintf(ucode_str, sizeof(ucode_str), "Glyph:U+%04X", ucode);
+    }
+
+    if (datasize < 0 || datasize > FV1_MAX_GLYPH_DATASIZE)
+    {
+
+        /* shouldn't happen */
+        LOG(LOG_LEVEL_ERROR, "%s - datasize %d out of bounds",
+            ucode_str, datasize);
+    }
+    else
+    {
+        glyph = (struct fv1_glyph *)
+                g_malloc( offsetof(struct fv1_glyph, data) + datasize, 1);
+
+        if (glyph == NULL)
+        {
+            LOG(LOG_LEVEL_ERROR, "%s - out of memory", ucode_str);
+        }
+        else
+        {
+            glyph->width = width;
+            glyph->height = height;
+        }
+    }
+
+    return glyph;
+}
+
+/*****************************************************************************/
+struct fv1_file *
+fv1_file_create(void)
+{
+    struct fv1_file *fv1 = (struct fv1_file *)g_new0(struct fv1_file, 1);
+    if (fv1 == NULL)
+    {
+        LOG(LOG_LEVEL_ERROR, "fv1_file_create - out of memory");
+    }
+    else
+    {
+        fv1->style = 1; /* Unused at present - compatibility value */
+        fv1->glyphs = list_create();
+        fv1->glyphs->auto_free = 1;
+    }
+    return fv1;
+}
+
+/*****************************************************************************/
+static void
+add_glyphs_from_stream(struct fv1_file *fv1, struct stream *s)
+{
+    unsigned short width;
+    unsigned short height;
+    int datasize;
+
+    struct fv1_glyph *glyph;
+
+    while (s_check_rem(s, 4))
+    {
+        in_sint16_le(s, width);
+        in_sint16_le(s, height);
+
+        datasize = FONT_DATASIZE_FROM_GEOMETRY(width, height);
+
+        if (datasize < 0 || datasize > FV1_MAX_GLYPH_DATASIZE)
+        {
+            LOG(LOG_LEVEL_ERROR,
+                "Font:%s Glyph:%d - datasize %d out of bounds",
+                fv1->font_name, FV1_GLYPH_END(fv1), datasize);
+            break;
+        }
+
+        if (!s_check_rem(s, 6 + 6 + datasize))
+        {
+            LOG(LOG_LEVEL_ERROR,
+                "Font:%s Glyph:%d - not enough data for glyph",
+                fv1->font_name, FV1_GLYPH_END(fv1));
+            break;
+        }
+
+        if ((glyph = fv1_alloc_glyph(FV1_GLYPH_END(fv1), width, height)) == NULL)
+        {
+            break;
+        }
+
+        in_sint16_le(s, glyph->baseline);
+        in_sint16_le(s, glyph->offset);
+        in_sint16_le(s, glyph->inc_by);
+        in_uint8s(s, 6);
+
+        in_uint8a(s, glyph->data, datasize);
+
+        list_add_item(fv1->glyphs, (tintptr)glyph);
+    }
+}
+
+/*****************************************************************************/
+struct fv1_file *
+fv1_file_load(const char *filename)
+{
+    struct fv1_file *fv1 = NULL;
+
+    if (!g_file_exist(filename))
+    {
+        LOG(LOG_LEVEL_ERROR, "Can't find font file %s", filename);
+    }
+    else
+    {
+        int file_size = g_file_get_size(filename);
+        if (file_size < FV1_MIN_FILE_SIZE || file_size > FV1_MAX_FILE_SIZE)
+        {
+            LOG(LOG_LEVEL_ERROR, "Font file %s has bad size %d",
+                filename, file_size);
+        }
+        else
+        {
+            struct stream *s;
+            int fd;
+            make_stream(s);
+            init_stream(s, file_size + 1024);
+            fd = g_file_open(filename);
+
+            if (fd < 0)
+            {
+                LOG(LOG_LEVEL_ERROR, "Can't open font file %s", filename);
+            }
+            else
+            {
+                int b = g_file_read(fd, s->data, file_size + 1024);
+                g_file_close(fd);
+
+                if (b < FV1_MIN_FILE_SIZE)
+                {
+                    LOG(LOG_LEVEL_ERROR, "Font file %s is too small",
+                        filename);
+                }
+                else
+                {
+                    char sig[sizeof(FV1_SIGNATURE)];
+                    s->end = s->data + b;
+                    in_uint8a(s, sig, sizeof(FV1_SIGNATURE));
+                    if (g_memcmp(sig, FV1_SIGNATURE, sizeof(sig)) != 0)
+                    {
+                        LOG(LOG_LEVEL_ERROR,
+                            "Font file %s has wrong signature",
+                            filename);
+                    }
+                    else if ((fv1 = fv1_file_create()) != NULL)
+                    {
+                        in_uint8a(s, fv1->font_name, FV1_MAX_FONT_NAME_SIZE);
+                        fv1->font_name[FV1_MAX_FONT_NAME_SIZE] = '\0';
+                        in_uint16_le(s, fv1->point_size);
+                        in_uint16_le(s, fv1->style);
+                        in_uint16_le(s, fv1->body_height);
+                        in_uint16_le(s, fv1->min_descender);
+                        in_uint8s(s, 4);
+
+                        add_glyphs_from_stream(fv1, s);
+                    }
+                }
+            }
+
+            free_stream(s);
+        }
+    }
+
+    return fv1;
+}
+
+/*****************************************************************************/
+void
+fv1_file_free(struct fv1_file *fv1)
+{
+    if (fv1 != NULL)
+    {
+        list_delete(fv1->glyphs);
+        g_free(fv1);
+    }
+}
+
+/*****************************************************************************/
+int
+write_stream(int fd, struct stream *s)
+{
+    const char *p = s->data;
+    int rv = 1;
+
+    while (p < s->end)
+    {
+        int len = g_file_write(fd, p, s->end - p);
+        if (len <= 0)
+        {
+            rv = 0;
+            break;
+        }
+        p += len;
+    }
+
+    return rv;
+}
+
+/*****************************************************************************/
+int
+fv1_file_save(const struct fv1_file *fv1, const char *filename)
+{
+    int fd;
+    struct fv1_glyph *blank_glyph; /* Needed for bad characters */
+
+    fd = g_file_open_ex(filename, 0, 1, 1, 1);
+    int rv = 1;
+    if (fd < 0)
+    {
+        LOG(LOG_LEVEL_ERROR, "Unable to open %s for writing [%s]", filename,
+            g_get_strerror());
+    }
+    else
+    {
+        struct stream *s;
+        make_stream(s);
+        init_stream(s, 1024);
+
+        /* Write the header */
+        out_uint8a(s, FV1_SIGNATURE, sizeof(FV1_SIGNATURE));
+        int len = g_strlen(fv1->font_name);
+        if (len > FV1_MAX_FONT_NAME_SIZE)
+        {
+            len = FV1_MAX_FONT_NAME_SIZE;
+        }
+        out_uint8a(s, fv1->font_name,  len);
+        while (len++ < FV1_MAX_FONT_NAME_SIZE)
+        {
+            out_uint8(s, '\0');
+        }
+        out_uint16_le(s, fv1->point_size);
+        out_uint16_le(s, fv1->style);
+        out_uint16_le(s, fv1->body_height);
+        out_uint16_le(s, fv1->min_descender);
+        out_uint8a(s, "\0\0\0\0", 4);
+        s_mark_end(s);
+        if (!write_stream(fd, s))
+        {
+            LOG(LOG_LEVEL_ERROR, "Unable to write file header [%s]",
+                g_get_strerror());
+        }
+        else if ((blank_glyph = fv1_alloc_glyph(-1, 0, 0)) == NULL)
+        {
+            LOG(LOG_LEVEL_ERROR, "Unable to allocate blank glyph");
+        }
+        else
+        {
+            int u;
+
+            for (u = FV1_MIN_CHAR; u < FV1_GLYPH_END(fv1); ++u)
+            {
+                const struct fv1_glyph *g = FV1_GET_GLYPH(fv1, u);
+                int datasize;
+                if (g == NULL)
+                {
+                    LOG(LOG_LEVEL_WARNING, "Glyph %d is not set", u);
+                    g = blank_glyph;
+                }
+                else
+                {
+                    datasize = FONT_DATASIZE(g);
+                    if (datasize > FV1_MAX_GLYPH_DATASIZE)
+                    {
+                        LOG(LOG_LEVEL_WARNING,
+                            "glyph %d datasize %d exceeds max of %d"
+                            " - glyph will be blank",
+                            u, datasize, FV1_MAX_GLYPH_DATASIZE);
+                        g = blank_glyph;
+                    }
+                }
+                init_stream(s, 16 + FONT_DATASIZE(g));
+                out_uint16_le(s, g->width);
+                out_uint16_le(s, g->height);
+                out_uint16_le(s, g->baseline);
+                out_uint16_le(s, g->offset);
+                out_uint16_le(s, g->inc_by);
+                out_uint8a(s, "\0\0\0\0\0\0", 6);
+                out_uint8a(s, g->data, FONT_DATASIZE(g));
+                s_mark_end(s);
+
+                if (!write_stream(fd, s))
+                {
+                    LOG(LOG_LEVEL_ERROR, "Unable to write glyph %d [%s]",
+                        u, g_get_strerror());
+                    break;
+                }
+            }
+            g_free(blank_glyph);
+
+            rv = (u == FV1_GLYPH_END(fv1)) ? 0 : 1;
+        }
+        free_stream(s);
+        g_file_close(fd);
+    }
+
+    return rv;
+}
--- a/fontutils/fv1.h
+++ b/fontutils/fv1.h
@ -0,0 +1,100 @@
+/**
+ * xrdp: A Remote Desktop Protocol server.
+ *
+ * Copyright (C) Jay Sorg 2004-2022
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file    fontutils/fv1.h
+ * @brief   Definitions relating to fv1 font files
+ */
+#if !defined(FV1_H)
+#define FV1_H
+
+struct list;
+
+#define FV1_DEVICE_DPI 96
+
+#define FV1_MIN_CHAR 0x20  /* First character value in file */
+
+#define FV1_MIN_FILE_SIZE 48
+#define FV1_MAX_FILE_SIZE (10 * 1024 * 1024)
+#define FV1_MAX_FONT_NAME_SIZE 32
+
+#define FV1_MAX_GLYPH_DATASIZE 512
+
+struct fv1_glyph
+{
+    unsigned short width;   /* Width of glyph */
+    unsigned short height;  /* Height of glyph */
+    short baseline; /* Offset from cursor pos to 1st row of glyph */
+    short offset; /* Space before glyph (can be -ve) */
+    unsigned short inc_by; /* Total width of glyph + spacing */
+    /* Standard C++ does not yet support C99 flexible array members */
+#ifdef __cplusplus
+    unsigned char data[1];
+#else
+    unsigned char data[];
+#endif
+};
+
+struct fv1_file
+{
+    char font_name[FV1_MAX_FONT_NAME_SIZE + 1];
+    short point_size; /* Input point size (for reference) */
+    short style;
+    short body_height; /* Body height (pixels) */
+    short min_descender; /* Min descender of the glyphs in the font */
+    struct list *glyphs; /* Glyphs are struct fv1_glyph * */
+
+};
+
+/**
+ * Get a glyph pointer for a unicode character
+ */
+#define FV1_GET_GLYPH(fv1,ucode) \
+    (((ucode) < FV1_MIN_CHAR) \
+     ? NULL \
+     : (struct fv1_glyph *)list_get_item(fv1->glyphs, (ucode) - FV1_MIN_CHAR))
+
+/**
+ * First glyph not in file
+ */
+#define FV1_GLYPH_END(fv1) (fv1->glyphs->count + FV1_MIN_CHAR)
+
+struct fv1_file *
+fv1_file_load(const char *filename);
+
+void
+fv1_file_free(struct fv1_file *);
+
+struct fv1_file *
+fv1_file_create(void);
+
+struct fv1_glyph *
+fv1_alloc_glyph(int ucode, /* Unicode character for error reporting if known */
+                unsigned short width,
+                unsigned short height);
+
+enum fv1_realloc_mode
+{
+    FV1_AT_TOP,
+    FV1_AT_BOTTOM
+};
+
+int
+fv1_file_save(const struct fv1_file *fv1, const char *filename);
+
+#endif
--- a/fontutils/mkfv1.c
+++ b/fontutils/mkfv1.c
@ -0,0 +1,587 @@
+/**
+ * xrdp: A Remote Desktop Protocol server.
+ *
+ * Copyright (C) Jay Sorg 2004-2012
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#if defined(HAVE_CONFIG_H)
+#include <config_ac.h>
+#endif
+
+#include <unistd.h>
+#include <ctype.h>
+#include <ft2build.h>
+#include FT_FREETYPE_H
+
+/* See the FT2 documentation - this builds an error table */
+#undef FTERRORS_H_
+#define FT_ERRORDEF( e, v, s )  { e, s },
+#define FT_ERROR_START_LIST     {
+#define FT_ERROR_END_LIST       { 0, NULL } };
+
+static const struct
+{
+    int          err_code;
+    const char  *err_msg;
+} ft_errors[] =
+#include <freetype/fterrors.h>
+
+#if 0
+    /* These lines fix problems with astyle formatting following the ft_errors
+     * definition */
+}
+#endif
+
+
+#include "arch.h"
+#include "defines.h"
+#include "log.h"
+#include "os_calls.h"
+#include "string_calls.h"
+
+#include "fv1.h"
+
+#define DEFAULT_POINT_SIZE 10
+#define DEFAULT_MAX_CHAR 0x4dff
+
+/**
+ * sans10 compatibility choices
+ */
+enum sans10_compat
+{
+    S10_OFF = 0,
+    S10_ON,
+    S10_AUTO
+};
+
+/**
+ * Parsed program arguments
+ */
+struct program_args
+{
+    const char *input_file;
+    const char *output_file;
+    char font_name[FV1_MAX_FONT_NAME_SIZE + 1];
+    unsigned short point_size;
+    /** Last character value in file */
+    unsigned int max_ucode;
+    /** Are we generating san10 in compatibility mode? */
+    enum sans10_compat sans10_compatibility;
+};
+
+struct x_dimensions
+{
+    unsigned short width;
+    short offset;
+    unsigned short inc_by;
+};
+
+/**
+ * Table of some character settings in the original sans-10.fv1 font
+ */
+static const struct x_dimensions
+    original_sans10_data[] =
+{
+    /* 0x20 - 0x3f */
+    {1, 0, 4}, {1, 2, 5}, {3, 1, 5}, {9, 1, 11},
+    {7, 1, 8}, {11, 0, 12}, {9, 1, 11}, {1, 1, 3},
+    {3, 1, 5}, {3, 1, 5}, {7, 0, 7}, {9, 1, 11},
+    {2, 1, 4}, {3, 1, 5}, {1, 2, 4}, {4, 0, 4},
+    {6, 1, 8}, {5, 2, 8}, {6, 1, 8}, {6, 1, 8},
+    {6, 1, 8}, {6, 1, 8}, {6, 1, 8}, {6, 1, 8},
+    {6, 1, 8}, {6, 1, 8}, {1, 2, 4}, {2, 1, 4},
+    {8, 1, 11}, {8, 1, 11}, {8, 1, 11}, {5, 1, 7},
+    /* 0x40 - 0x5f */
+    {11, 1, 13}, {9, 0, 9}, {7, 1, 9}, {7, 1, 9},
+    {8, 1, 10}, {6, 1, 8}, {5, 1, 7}, {8, 1, 10},
+    {8, 1, 10}, {1, 1, 3}, {3, -1, 3}, {7, 1, 8},
+    {6, 1, 7}, {9, 1, 11}, {8, 1, 10}, {8, 1, 10},
+    {6, 1, 8}, {8, 1, 10}, {7, 1, 8}, {7, 1, 9},
+    {7, 0, 7}, {8, 1, 10}, {9, 0, 9}, {11, 0, 11},
+    {8, 0, 8}, {7, 0, 7}, {8, 1, 10}, {3, 1, 5},
+    {4, 0, 4}, {3, 1, 5}, {8, 1, 11}, {7, 0, 7},
+    /* 0x60 - 0x7f */
+    {3, 1, 7}, {6, 1, 8}, {6, 1, 8}, {5, 1, 7},
+    {6, 1, 8}, {6, 1, 8}, {4, 0, 4}, {6, 1, 8},
+    {6, 1, 8}, {1, 1, 3}, {2, 0, 3}, {6, 1, 7},
+    {1, 1, 3}, {11, 1, 13}, {6, 1, 8}, {6, 1, 8},
+    {6, 1, 8}, {6, 1, 8}, {4, 1, 5}, {5, 1, 7},
+    {4, 0, 5}, {6, 1, 8}, {7, 0, 7}, {9, 0, 9},
+    {7, 0, 7}, {7, 0, 7}, {5, 1, 7}, {5, 2, 8},
+    {1, 2, 4}, {5, 2, 8}, {8, 1, 11}, {7, 1, 8},
+    /* 0x80 - 0x9f */
+    {7, 1, 8}, {7, 1, 8}, {7, 1, 8}, {7, 1, 8},
+    {7, 1, 8}, {7, 1, 8}, {7, 1, 8}, {7, 1, 8},
+    {7, 1, 8}, {7, 1, 8}, {7, 1, 8}, {7, 1, 8},
+    {7, 1, 8}, {7, 1, 8}, {7, 1, 8}, {7, 1, 8},
+    {7, 1, 8}, {7, 1, 8}, {7, 1, 8}, {7, 1, 8},
+    {7, 1, 8}, {7, 1, 8}, {7, 1, 8}, {7, 1, 8},
+    {7, 1, 8}, {7, 1, 8}, {7, 1, 8}, {7, 1, 8},
+    {7, 1, 8}, {7, 1, 8}, {7, 1, 8}, {7, 1, 8},
+    /* 0xa0 - 0xbf */
+    {1, 0, 4}, {1, 2, 5}, {6, 1, 8}, {7, 0, 8},
+    {7, 0, 8}, {7, 1, 8}, {1, 2, 4}, {5, 1, 7},
+    {3, 2, 7}, {9, 2, 13}, {5, 1, 6}, {6, 1, 8},
+    {8, 1, 11}, {3, 1, 5}, {9, 2, 13}, {4, 1, 7},
+    {4, 1, 7}, {9, 1, 11}, {4, 1, 5}, {4, 1, 5},
+    {3, 2, 7}, {7, 1, 8}, {6, 1, 8}, {1, 1, 4},
+    {3, 2, 7}, {3, 1, 5}, {5, 1, 6}, {6, 1, 8},
+    {12, 1, 13}, {11, 1, 13}, {12, 1, 13}, {5, 1, 7},
+    /* 0xc0 - 0xdf */
+    {9, 0, 9}, {9, 0, 9}, {9, 0, 9}, {9, 0, 9},
+    {9, 0, 9}, {9, 0, 9}, {12, 0, 13}, {7, 1, 9},
+    {6, 1, 8}, {6, 1, 8}, {6, 1, 8}, {6, 1, 8},
+    {2, 0, 3}, {2, 1, 3}, {5, -1, 3}, {3, 0, 3},
+    {9, 0, 10}, {8, 1, 10}, {8, 1, 10}, {8, 1, 10},
+    {8, 1, 10}, {8, 1, 10}, {8, 1, 10}, {7, 2, 11},
+    {8, 1, 10}, {8, 1, 10}, {8, 1, 10}, {8, 1, 10},
+    {8, 1, 10}, {7, 0, 7}, {6, 1, 8}, {6, 1, 8},
+    /* 0xe0 - 0xff */
+    {6, 1, 8}, {6, 1, 8}, {6, 1, 8}, {6, 1, 8},
+    {6, 1, 8}, {6, 1, 8}, {11, 1, 13}, {5, 1, 7},
+    {6, 1, 8}, {6, 1, 8}, {6, 1, 8}, {6, 1, 8},
+    {3, 0, 3}, {3, 1, 3}, {5, -1, 3}, {3, 0, 3},
+    {6, 1, 8}, {6, 1, 8}, {6, 1, 8}, {6, 1, 8},
+    {6, 1, 8}, {6, 1, 8}, {6, 1, 8}, {8, 1, 11},
+    {6, 1, 8}, {6, 1, 8}, {6, 1, 8}, {6, 1, 8},
+    {6, 1, 8}, {7, 0, 7}, {6, 1, 8}, {7, 0, 7}
+};
+
+
+/**************************************************************************//**
+ * Parses a unicode character value
+ *
+ * @param str String containing value
+ * @return Resulting character value
+ */
+static unsigned int
+parse_ucode_name(const char *str)
+{
+    unsigned int rv;
+    if (toupper(str[0]) == 'U' && str[1] == '+')
+    {
+        char *hex = g_strdup(str);
+        hex[0] = '0';
+        hex[1] = 'x';
+        rv = g_atoix(hex);
+        g_free(hex);
+    }
+    else if (str[0] == '@')
+    {
+        rv = str[1];
+    }
+    else
+    {
+        rv = g_atoix(str);
+    }
+    return rv;
+}
+
+/**************************************************************************//**
+ * Parses the program args
+ *
+ * @param argc Passed to main
+ * @param @argv Passed to main
+ * @param pa program_pargs structure for resulting values
+ * @return !=0 for success
+ */
+static int
+parse_program_args(int argc, char *argv[], struct program_args *pa)
+{
+    int params_ok = 1;
+    int opt;
+
+    pa->input_file = NULL;
+    pa->output_file = NULL;
+    pa->font_name[0] = '\0';
+    pa->point_size = DEFAULT_POINT_SIZE;
+    pa->max_ucode = DEFAULT_MAX_CHAR;
+    pa->sans10_compatibility = S10_AUTO;
+
+    while ((opt = getopt(argc, argv, "n:p:m:C:")) != -1)
+    {
+        switch (opt)
+        {
+            case 'n':
+                g_snprintf(pa->font_name, FV1_MAX_FONT_NAME_SIZE + 1, "%s",
+                           optarg);
+                break;
+
+            case 'p':
+                pa->point_size = g_atoi(optarg);
+                break;
+
+            case 'm':
+                pa->max_ucode = parse_ucode_name(optarg);
+                break;
+
+            case 'C':
+                if (toupper(optarg[0]) == 'A')
+                {
+                    pa->sans10_compatibility = S10_AUTO;
+                }
+                else if (g_text2bool(optarg))
+                {
+                    pa->sans10_compatibility = S10_ON;
+                }
+                else
+                {
+                    pa->sans10_compatibility = S10_OFF;
+                }
+                break;
+
+            default:
+                LOG(LOG_LEVEL_ERROR, "Unrecognised switch '%c'", (char)opt);
+                params_ok = 0;
+        }
+    }
+
+    if (pa->max_ucode < FV1_MIN_CHAR)
+    {
+        LOG(LOG_LEVEL_ERROR, "-m argument must be at least %d",
+            FV1_MIN_CHAR);
+        params_ok = 0;
+    }
+
+    switch (argc - optind)
+    {
+        case 0:
+            LOG(LOG_LEVEL_ERROR, "No input file specified");
+            params_ok = 0;
+            break;
+
+        case 1:
+            LOG(LOG_LEVEL_ERROR, "No output file specified");
+            params_ok = 0;
+            break;
+        case 2:
+            pa->input_file = argv[optind];
+            pa->output_file = argv[optind + 1];
+            break;
+
+        default:
+            LOG(LOG_LEVEL_ERROR, "Unexpected arguments after output file");
+            params_ok = 0;
+    }
+
+    return params_ok;
+}
+
+/**************************************************************************//**
+ * Checks whether the specified glyph row is blank
+ * @param g Glyph
+ * @param row Row number between 0 and g->height - 1
+ * @result Boolean
+ */
+static int
+is_blank_glyph_row(const struct fv1_glyph *g, unsigned int row)
+{
+    if (g->width == 0 || row >= g->height)
+    {
+        return 1;
+    }
+
+    const unsigned int glyph_row_size = ((g->width + 7) / 8);
+    const unsigned char *dataptr = g->data + (row * glyph_row_size);
+    const unsigned int masks[] =
+    { 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe, 0xff };
+
+    /* Check for set pixels in all the leading bytes */
+    unsigned int x;
+    for (x = g->width ; x > 8 ; x -= 8)
+    {
+        if (*dataptr++ != 0)
+        {
+            return 0;
+        }
+    }
+
+    /* Use a single test to check the pixels in the last byte */
+    return ((*dataptr & masks[x - 1]) == 0);
+}
+
+/**************************************************************************//**
+ * Returns a string for a freetype2 error
+ * @param error Freetype2 error code
+ * @param buff Pointer to buffer for error string
+ * @param bufflen Length of above
+ */
+static void
+get_ft_error(FT_Error error, char *buff, unsigned int bufflen)
+{
+    const char *errstr = NULL;
+    unsigned int i;
+    for (i = 0 ; i < (sizeof(ft_errors) / sizeof(ft_errors[0])); ++i)
+    {
+        if (ft_errors[i].err_code == error)
+        {
+            errstr = ft_errors[i].err_msg;
+            break;
+        }
+    }
+
+    if (errstr != NULL)
+    {
+        g_snprintf(buff, bufflen, "[%s]", errstr);
+    }
+    else
+    {
+        g_snprintf(buff, bufflen,
+                   "[errorcode %d (no description)]", (int)error);
+    }
+}
+
+/**************************************************************************//**
+ * Implement sans10 compatibility for a glyph
+ *
+ * The original Windows font generator made a few different choices for the
+ * character x offset than freetype2 does. These are particularly noticeable
+ * with a small font.
+ *
+ * This routine checks the glyph, and implements the original offset size
+ * for popular English characters, which are all that the user will probably
+ * be displaying with xrdp v0.9.x
+ *
+ * @param g Glyph to check
+ */
+static void
+implement_sans10_compatibility(struct fv1_glyph *g, unsigned int ucode)
+{
+    const unsigned int max_index =
+        sizeof(original_sans10_data) / sizeof(original_sans10_data[0]);
+
+    if (ucode < FV1_MIN_CHAR || ucode >= max_index + FV1_MIN_CHAR)
+    {
+        return;
+    }
+
+    const struct x_dimensions *d =
+            &original_sans10_data[ucode - FV1_MIN_CHAR];
+
+    if (g->offset != d->offset)
+    {
+        if (g->width != d->width)
+        {
+            LOG(LOG_LEVEL_WARNING,
+                "Can't set compatibility offset for U+%04X: width %d != %d",
+                ucode, g->width, d->width);
+        }
+        else if (g->inc_by != d->inc_by)
+        {
+            LOG(LOG_LEVEL_WARNING,
+                "Can't set compatibility offset for U+%04X: inc_by %d != %d",
+                ucode, g->inc_by, d->inc_by);
+        }
+        else
+        {
+            LOG(LOG_LEVEL_INFO,
+                "Changing compatibility offset for U+%04X: from %d to %d",
+                ucode, g->offset, d->offset);
+        }
+
+        g->offset = d->offset;
+    }
+}
+
+/**************************************************************************//**
+ * Converts a freetype 2 bitmap to a fv1 glyph
+ * @param ft_glyph Freetype2 glyph. Must be a monochrome bitmap
+ * @param ucode Unicode character for error reporting
+ * @param pa Program args
+ * @return fv1 glyph, or NULL for error
+ */
+static struct fv1_glyph *
+convert_mono_glyph(FT_GlyphSlot ft_glyph, unsigned int ucode,
+                   const struct program_args *pa)
+{
+    short width = ft_glyph->bitmap.width;
+    short height =  ft_glyph->bitmap.rows;
+    struct fv1_glyph *g;
+
+    /* Number of bytes in a glyph row */
+    const unsigned int glyph_row_size = ((width + 7) / 8);
+
+    if ((g = fv1_alloc_glyph(ucode, width, height)) != NULL)
+    {
+        g->baseline = -(ft_glyph->metrics.horiBearingY / 64);
+        g->offset = ft_glyph->metrics.horiBearingX / 64;
+        g->inc_by = ft_glyph->metrics.horiAdvance / 64;
+
+        if (FONT_DATASIZE(g) > 0)
+        {
+            const unsigned char *srcptr = ft_glyph->bitmap.buffer;
+            unsigned char *dstptr = g->data;
+            unsigned int y;
+
+            for (y = 0; y < g->height; ++y)
+            {
+                g_memcpy(dstptr, srcptr, glyph_row_size);
+                dstptr += glyph_row_size;
+                srcptr += ft_glyph->bitmap.pitch;
+            }
+
+            /* Optimise the glyph by removing any blank lines at the bottom
+             * and top */
+            if (g->width > 0)
+            {
+                while (g->height > 0 &&
+                        is_blank_glyph_row(g, g->height - 1))
+                {
+                    --g->height;
+                }
+
+                y = 0;
+                while (y < g->height && is_blank_glyph_row(g, y))
+                {
+                    ++y;
+                }
+
+                if (y > 0)
+                {
+                    g->baseline += y;
+                    g->height -= y;
+                    g_memmove(g->data, g->data + (y * glyph_row_size),
+                              g->height * glyph_row_size);
+                }
+            }
+        }
+    }
+
+    if (pa->sans10_compatibility != S10_OFF)
+    {
+        implement_sans10_compatibility(g, ucode);
+    }
+
+    return g;
+}
+
+/**************************************************************************//**
+ * Main
+ *
+ * @param argc Argument count
+ * @param argv Arguments
+ */
+int
+main(int argc, char *argv[])
+{
+    FT_Library library = NULL;   /* handle to library     */
+    FT_Face face = NULL;      /* handle to face object */
+    FT_Error error;
+    struct fv1_glyph *g;
+    struct program_args pa;
+    struct log_config *logging;
+    int rv = 1;
+
+    logging = log_config_init_for_console(LOG_LEVEL_WARNING,
+                                          g_getenv("MKFV1_LOG_LEVEL"));
+    log_start_from_param(logging);
+    log_config_free(logging);
+
+    struct fv1_file *fv1 = fv1_file_create();
+
+    if (fv1 == NULL)
+    {
+        LOG(LOG_LEVEL_ERROR, "Memory allocation failure");
+    }
+    else if (parse_program_args(argc, argv, &pa))
+    {
+        char errstr[128];
+
+        if ((error = FT_Init_FreeType(&library)) != 0)
+        {
+            get_ft_error(error, errstr, sizeof(errstr));
+            LOG(LOG_LEVEL_ERROR, "Error initializing freetype library %s",
+                errstr);
+        }
+        else if ((error = FT_New_Face(library, pa.input_file, 0, &face)) != 0)
+        {
+            get_ft_error(error, errstr, sizeof(errstr));
+            LOG(LOG_LEVEL_ERROR, "Error loading font file %s %s",
+                pa.input_file, errstr);
+        }
+        else if ((error = FT_Set_Char_Size(face, 0,
+                                           pa.point_size * 64,
+                                           FV1_DEVICE_DPI, 0)) != 0)
+        {
+            get_ft_error(error, errstr, sizeof(errstr));
+            LOG(LOG_LEVEL_ERROR, "Error setting point size to %u %s",
+                pa.point_size, errstr);
+        }
+        else
+        {
+            const char *fname =
+                (pa.font_name[0] != '\0') ?  pa.font_name :
+                (face->family_name != NULL) ? face->family_name :
+                /* Default */ "";
+
+            g_snprintf(fv1->font_name, FV1_MAX_FONT_NAME_SIZE + 1, "%s", fname);
+            fv1->point_size = pa.point_size;
+            fv1->body_height = face->size->metrics.height / 64;
+            fv1->min_descender = face->size->metrics.descender / 64;
+
+            if (pa.sans10_compatibility == S10_AUTO)
+            {
+                if (g_strcmp(fv1->font_name, "DejaVu Sans") == 0 &&
+                        fv1->point_size == 10)
+                {
+                    pa.sans10_compatibility = S10_ON;
+                }
+                else
+                {
+                    pa.sans10_compatibility = S10_OFF;
+                }
+            }
+
+            unsigned int u;
+            for (u = FV1_MIN_CHAR; u <= pa.max_ucode; ++u)
+            {
+                /* retrieve glyph index from character code */
+                FT_UInt glyph_index = FT_Get_Char_Index(face, u);
+
+                /* load glyph image into the slot (erase previous one) */
+                error = FT_Load_Glyph(face, glyph_index,
+                                      FT_LOAD_RENDER | FT_LOAD_TARGET_MONO);
+                if (error)
+                {
+                    get_ft_error(error, errstr, sizeof(errstr));
+                    LOG(LOG_LEVEL_WARNING,
+                        "Unable to get bitmap for U+%04X %s", u, errstr);
+                    g = NULL;
+                }
+                else if (face->glyph->format != FT_GLYPH_FORMAT_BITMAP ||
+                         face->glyph->bitmap.pixel_mode != FT_PIXEL_MODE_MONO)
+                {
+                    LOG(LOG_LEVEL_WARNING,
+                        "Internal error; U+%04X was not loaded as a bitmap",
+                        u);
+                    g = NULL;
+                }
+                else
+                {
+                    g = convert_mono_glyph(face->glyph, u, &pa);
+                }
+                list_add_item(fv1->glyphs, (tintptr)g);
+            }
+
+            rv = fv1_file_save(fv1,  pa.output_file);
+        }
+    }
+
+    FT_Done_FreeType(library);
+    fv1_file_free(fv1);
+    log_end();
+
+    return rv;
+}
--- a/fontutils/windows/.gitignore
+++ b/fontutils/windows/.gitignore
--- a/fontutils/windows/Makefile
+++ b/fontutils/windows/Makefile
--- a/fontutils/windows/fontdump.c
+++ b/fontutils/windows/fontdump.c
--- a/xrdp/Makefile.am
+++ b/xrdp/Makefile.am
@ -99,5 +99,6 @@ dist_xrdppkgdata_DATA = \
  xrdp256.bmp \
  xrdp_logo.bmp \
  sans-10.fv1 \
+  sans-18.fv1 \
  cursor0.cur \
  cursor1.cur
--- a/xrdp/sans-10.fv1
+++ b/xrdp/sans-10.fv1
--- a/xrdp/sans-18.fv1
+++ b/xrdp/sans-18.fv1
--- a/xrdp/xrdp.h
+++ b/xrdp/xrdp.h
@ -301,8 +301,8 @@ xrdp_painter_draw_bitmap(struct xrdp_painter *self,
                         int x, int y, int cx, int cy);
 int
 xrdp_painter_text_width(struct xrdp_painter *self, const char *text);
-int
-xrdp_painter_text_height(struct xrdp_painter *self, const char *text);
+unsigned int
+xrdp_painter_font_body_height(const struct xrdp_painter *self);
 int
 xrdp_painter_draw_text(struct xrdp_painter *self,
                       struct xrdp_bitmap *bitmap,
@ -343,7 +343,7 @@ xrdp_painter_line(struct xrdp_painter *self,

 /* xrdp_font.c */
 struct xrdp_font *
-xrdp_font_create(struct xrdp_wm *wm);
+xrdp_font_create(struct xrdp_wm *wm, unsigned int dpi);
 void
 xrdp_font_delete(struct xrdp_font *self);
 int
@ -387,10 +387,20 @@ int
 get_keymaps(int keylayout, struct xrdp_keymap *keymap);

 /* xrdp_login_wnd.c */
+/**
+ * Gets the DPI of the login (primary) monitor
+ *
+ * @param self xrdp_wm instance
+ * @return DPI of primary monitor, or 0 if unavailable.
+ */
+unsigned int
+xrdp_login_wnd_get_monitor_dpi(struct xrdp_wm *self);
 int
 xrdp_login_wnd_create(struct xrdp_wm *self);
 int
 load_xrdp_config(struct xrdp_config *config, const char *xrdp_ini, int bpp);
+void
+xrdp_login_wnd_scale_config_values(struct xrdp_wm *self);

 /* xrdp_bitmap_compress.c */
 int
--- a/xrdp/xrdp.ini.in
+++ b/xrdp/xrdp.ini.in
@ -106,6 +106,17 @@ grey=dedede
 #green=00ff00
 #background=626c72

+;
+; Select a default fv1 font
+;
+; This parameter is a comma-separated list of DPI:name pairs.
+; The list is scanned from left-to-right. The font used is the first
+; font whose DPI value is less-than-or-equal to the vertical DPI of
+; the monitor used for the login screen.
+#fv1_select=130:sans-18.fv1,0:sans-10.fv1
+; Default DPI used for a monitor when that information is unknown
+#default_dpi=96
+
 ;
 ; configure login screen
 ;
@ -118,6 +129,10 @@ ls_top_window_bg_color=009cb5

 ; width and height of login screen
 ;
+; When the sans-10.fv1 font is selected, these values are in pixels.
+; For other fonts, these values (and other size values) will be scaled
+; appropriately to preserve the proportions of the login screen.
+;
 ; The default height allows for about 5 fields to be comfortably displayed
 ; above the buttons at the bottom. To display more fields, make <ls_height>
 ; larger, and also increase <ls_btn_ok_y_pos> and <ls_btn_cancel_y_pos>
@ -147,15 +162,15 @@ ls_bg_color=dedede
 ; For transform values, see 'ls_background_transform'. The logo width and
 ; logo height are ignored for a transform of 'none'.
 ls_logo_filename=
-#ls_logo_transform=none
-#ls_logo_width=240
-#ls_logo_height=140
+ls_logo_transform=scale
+ls_logo_width=240
+ls_logo_height=140
 ls_logo_x_pos=55
 ls_logo_y_pos=50

 ; for positioning labels such as username, password etc
 ls_label_x_pos=30
-ls_label_width=65
+ls_label_width=68

 ; for positioning text and combo boxes next to above labels
 ls_input_x_pos=110
--- a/xrdp/xrdp_bitmap.c
+++ b/xrdp/xrdp_bitmap.c
@ -111,6 +111,7 @@ int
 xrdp_bitmap_set_focus(struct xrdp_bitmap *self, int focused)
 {
    struct xrdp_painter *painter = (struct xrdp_painter *)NULL;
+    unsigned int font_height;

    if (self == 0)
    {
@ -125,19 +126,22 @@ xrdp_bitmap_set_focus(struct xrdp_bitmap *self, int focused)
    painter = xrdp_painter_create(self->wm, self->wm->session);
    xrdp_painter_font_needed(painter);
    xrdp_painter_begin_update(painter);
+    font_height = xrdp_painter_font_body_height(painter);

    if (focused)
    {
        /* active title bar */
        painter->fg_color = self->wm->blue;
-        xrdp_painter_fill_rect(painter, self, 3, 3, self->width - 5, 18);
+        xrdp_painter_fill_rect(painter, self, 3, 3,
+                               self->width - 5, font_height + 5);
        painter->fg_color = self->wm->white;
    }
    else
    {
        /* inactive title bar */
        painter->fg_color = self->wm->dark_grey;
-        xrdp_painter_fill_rect(painter, self, 3, 3, self->width - 5, 18);
+        xrdp_painter_fill_rect(painter, self, 3, 3,
+                               self->width - 5, font_height + 5);
        painter->fg_color = self->wm->black;
    }

@ -616,6 +620,7 @@ xrdp_bitmap_invalidate(struct xrdp_bitmap *self, struct xrdp_rect *rect)
    struct xrdp_rect r1;
    struct xrdp_rect r2;
    struct xrdp_painter *painter;
+    unsigned int font_height;
    twchar wtext[256];
    char text[256];
    char *p;
@ -632,6 +637,7 @@ xrdp_bitmap_invalidate(struct xrdp_bitmap *self, struct xrdp_rect *rect)

    painter = xrdp_painter_create(self->wm, self->wm->session);
    xrdp_painter_font_needed(painter);
+    font_height = xrdp_painter_font_body_height(painter);
    painter->rop = 0xcc; /* copy */

    if (rect == 0)
@ -684,14 +690,16 @@ xrdp_bitmap_invalidate(struct xrdp_bitmap *self, struct xrdp_rect *rect)
        {
            /* active title bar */
            painter->fg_color = self->wm->blue;
-            xrdp_painter_fill_rect(painter, self, 3, 3, self->width - 5, 18);
+            xrdp_painter_fill_rect(painter, self, 3, 3,
+                                   self->width - 5, font_height + 5);
            painter->fg_color = self->wm->white;
        }
        else
        {
            /* inactive title bar */
            painter->fg_color = self->wm->dark_grey;
-            xrdp_painter_fill_rect(painter, self, 3, 3, self->width - 5, 18);
+            xrdp_painter_fill_rect(painter, self, 3, 3,
+                                   self->width - 5, font_height + 5);
            painter->fg_color = self->wm->black;
        }

@ -742,7 +750,7 @@ xrdp_bitmap_invalidate(struct xrdp_bitmap *self, struct xrdp_rect *rect)
            xrdp_bitmap_draw_button(self, painter, 0, 0,
                                    self->width, self->height, 0);
            w = xrdp_painter_text_width(painter, self->caption1);
-            h = xrdp_painter_text_height(painter, self->caption1);
+            h = xrdp_painter_font_body_height(painter);
            painter->fg_color = self->wm->black;
            xrdp_painter_draw_text(painter, self, self->width / 2 - w / 2,
                                   self->height / 2 - h / 2, self->caption1);
@ -764,7 +772,7 @@ xrdp_bitmap_invalidate(struct xrdp_bitmap *self, struct xrdp_rect *rect)
            xrdp_bitmap_draw_button(self, painter, 0, 0,
                                    self->width, self->height, 1);
            w = xrdp_painter_text_width(painter, self->caption1);
-            h = xrdp_painter_text_height(painter, self->caption1);
+            h = xrdp_painter_font_body_height(painter);
            painter->fg_color = self->wm->black;
            xrdp_painter_draw_text(painter, self, (self->width / 2 - w / 2) + 1,
                                   (self->height / 2 - h / 2) + 1, self->caption1);
@ -941,7 +949,7 @@ xrdp_bitmap_invalidate(struct xrdp_bitmap *self, struct xrdp_rect *rect)
        if (self->popped_from != 0)
        {
            /* change height if there are too many items in the list */
-            i = xrdp_painter_text_height(painter, "W");
+            i = xrdp_painter_font_body_height(painter);
            i = self->popped_from->string_list->count * i;

            if (i > self->height)
@ -961,7 +969,7 @@ xrdp_bitmap_invalidate(struct xrdp_bitmap *self, struct xrdp_rect *rect)
            for (i = 0; i < self->popped_from->string_list->count; i++)
            {
                p = (char *)list_get_item(self->popped_from->string_list, i);
-                h = xrdp_painter_text_height(painter, p);
+                h = xrdp_painter_font_body_height(painter);
                self->item_height = h;

                if (i == self->item_index)
--- a/xrdp/xrdp_font.c
+++ b/xrdp/xrdp_font.c
@ -18,56 +18,127 @@
 * fonts
 */

-/*
-  The fv1 files contain
-  Font File Header (just one)
-    FNT1       4 bytes
-    Font Name  32 bytes
-    Font Size  2 bytes
-    Font Style 2 bytes
-    Pad        8 bytes
-  Font Data (repeats)
-    Width      2 bytes
-    Height     2 bytes
-    Baseline   2 bytes
-    Offset     2 bytes
-    Incby      2 bytes
-    Pad        6 bytes
-    Glyph Data var, see FONT_DATASIZE macro
-*/
+/* fv1 files are described in fontutils/README_fv1.txt */

 #if defined(HAVE_CONFIG_H)
 #include <config_ac.h>
 #endif

+#include <ctype.h>
+
 #include "xrdp.h"
 #include "log.h"
+#include "string_calls.h"

 #if 0 /* not used */
 static char w_char[] =
 {
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x08, 0x20, 0x80,
-    0x08, 0x50, 0x80,
-    0x04, 0x51, 0x00,
-    0x04, 0x51, 0x00,
-    0x04, 0x51, 0x00,
-    0x02, 0x8a, 0x00,
-    0x02, 0x8a, 0x00,
-    0x02, 0x8a, 0x00,
-    0x01, 0x04, 0x00,
-    0x01, 0x04, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
-    0x00, 0x00, 0x00,
+    0x00, 0x00, 0x00, // ........................
+    0x00, 0x00, 0x00, // ........................
+    0x00, 0x00, 0x00, // ........................
+    0x08, 0x20, 0x80, // ....X.....X.....X.......
+    0x08, 0x50, 0x80, // ....X....X.X....X.......
+    0x04, 0x51, 0x00, // .....X...X.X...X........
+    0x04, 0x51, 0x00, // .....X...X.X...X........
+    0x04, 0x51, 0x00, // .....X...X.X...X........
+    0x02, 0x8a, 0x00, // ......X.X...X.X.........
+    0x02, 0x8a, 0x00, // ......X.X...X.X.........
+    0x02, 0x8a, 0x00, // ......X.X...X.X.........
+    0x01, 0x04, 0x00, // .......X.....X..........
+    0x01, 0x04, 0x00, // .......X.....X..........
+    0x00, 0x00, 0x00, // ........................
+    0x00, 0x00, 0x00, // ........................
+    0x00, 0x00, 0x00, // ........................
 };
 #endif

+/*****************************************************************************/
+/**
+ * Parses the fv1_select configuration value to get the font to use,
+ * based on the DPI of the primary monitor
+ *
+ * @param globals Configuration globals
+ * @param dpi DPI of primary monitor. If not known, a suitable
+ *            default should be passed in here.
+ * @param[out] font_name Name of font to use
+ * @param[in] font_name_len Length of font name buffer
+ */
+static void
+get_font_name_from_dpi(const struct xrdp_cfg_globals *globals,
+                       unsigned int dpi,
+                       char *font_name, int font_name_len)
+{
+    int bad_selector = 0;
+
+    font_name[0] = '\0';
+
+    const char *fv1_select = globals->fv1_select;
+    if (fv1_select == NULL || fv1_select[0] == '\0')
+    {
+        fv1_select = DEFAULT_FV1_SELECT;
+    }
+
+    const char *p = fv1_select;
+
+    while (p != NULL)
+    {
+        /* DPI value must be next in string */
+        if (!isdigit(*p))
+        {
+            bad_selector = 1;
+            break;
+        }
+        unsigned int field_dpi = g_atoi(p);
+        if (field_dpi <= dpi)
+        {
+            /* Use this font */
+            p = g_strchr(p, ':');
+            if (p == NULL)
+            {
+                bad_selector = 1;
+            }
+            else
+            {
+                ++p;
+                const char *q = g_strchr(p, ',');
+                if (q == NULL)
+                {
+                    q = p + g_strlen(p);
+                }
+                if (q - p > (font_name_len - 1))
+                {
+                    q = p + font_name_len - 1;
+                }
+                g_memcpy(font_name, p, q - p);
+                font_name[q - p] = '\0';
+            }
+            break;
+        }
+        else
+        {
+            p = g_strchr(p, ',');
+            if (p != NULL)
+            {
+                ++p;
+            }
+        }
+    }
+
+    if (bad_selector)
+    {
+        LOG(LOG_LEVEL_WARNING, "Unable to parse fv1_select configuration");
+    }
+
+    if (font_name[0] == '\0')
+    {
+        LOG(LOG_LEVEL_WARNING, "Loading default font " DEFAULT_FONT_NAME);
+        g_snprintf(font_name, font_name_len, DEFAULT_FONT_NAME);
+    }
+}
+
 /*****************************************************************************/
 struct xrdp_font *
-xrdp_font_create(struct xrdp_wm *wm)
+xrdp_font_create(struct xrdp_wm *wm, unsigned int dpi)
 {
    struct xrdp_font *self;
    struct stream *s;
@ -78,17 +149,53 @@ xrdp_font_create(struct xrdp_wm *wm)
    int datasize;
    int file_size;
    struct xrdp_font_char *f;
-    char file_path[256];
-
+    const char *file_path;
+    char file_path_buff[256];
+    int min_descender;
+    char font_name[256];
+    const struct xrdp_cfg_globals *globals = &wm->xrdp_config->cfg_globals;
    LOG_DEVEL(LOG_LEVEL_TRACE, "in xrdp_font_create");
-    g_snprintf(file_path, 255, "%s/%s", XRDP_SHARE_PATH, DEFAULT_FONT_NAME);
+
+    if (dpi == 0)
+    {
+        LOG(LOG_LEVEL_WARNING, "No DPI value is available to find login font");
+        dpi = globals->default_dpi;
+        LOG(LOG_LEVEL_WARNING, "Using the default_dpi of %u", dpi);
+    }
+    get_font_name_from_dpi(globals, dpi, font_name, sizeof(font_name));
+
+    if (font_name[0] == '/')
+    {
+        /* User specified absolute path */
+        file_path = font_name;
+    }
+    else
+    {
+        g_snprintf(file_path_buff, sizeof(file_path_buff),
+                   XRDP_SHARE_PATH "/%s",
+                   font_name);
+        file_path = file_path_buff;
+    }

    if (!g_file_exist(file_path))
    {
-        LOG(LOG_LEVEL_ERROR, "xrdp_font_create: error font file [%s] does not exist",
-            file_path);
+        /* Try to fall back to the default */
+        const char *default_file_path = XRDP_SHARE_PATH "/" DEFAULT_FONT_NAME;
+        if (g_file_exist(default_file_path))
+        {
+            LOG(LOG_LEVEL_WARNING,
+                "xrdp_font_create: font file [%s] does not exist - using [%s]",
+                file_path, default_file_path);
+            file_path = default_file_path;
+        }
+        else
+        {
+            LOG(LOG_LEVEL_ERROR,
+                "xrdp_font_create: Can't load either [%s] or [%s]",
+                file_path, default_file_path);
            return 0;
        }
+    }

    file_size = g_file_get_size(file_path);

@ -117,7 +224,9 @@ xrdp_font_create(struct xrdp_wm *wm)
            in_uint8a(s, self->name, 32);
            in_uint16_le(s, self->size);
            in_uint16_le(s, self->style);
-            in_uint8s(s, 8);
+            in_uint16_le(s, self->body_height);
+            in_sint16_le(s, min_descender);
+            in_uint8s(s, 4);
            index = 32;

            while (s_check_rem(s, 16))
@ -128,7 +237,8 @@ xrdp_font_create(struct xrdp_wm *wm)
                in_sint16_le(s, i);
                f->height = i;
                in_sint16_le(s, i);
-                f->baseline = i;
+                /* Move the glyph up so there are no descenders */
+                f->baseline = i + min_descender;
                in_sint16_le(s, i);
                f->offset = i;
                in_sint16_le(s, i);
@ -145,7 +255,15 @@ xrdp_font_create(struct xrdp_wm *wm)
                    break;
                }

-                if (s_check_rem(s, datasize))
+                if (datasize == 0)
+                {
+                    /* Allocate a single blank pixel for the glyph, so
+                     * that it can be added to the glyph cache if required */
+                    f->width = 1;
+                    f->height = 1;
+                    f->data = (char *)g_malloc(1, 1);
+                }
+                else if (s_check_rem(s, datasize))
                {
                    f->data = (char *)g_malloc(datasize, 0);
                    in_uint8a(s, f->data, datasize);
@ -154,9 +272,15 @@ xrdp_font_create(struct xrdp_wm *wm)
                {
                    LOG(LOG_LEVEL_ERROR, "error in xrdp_font_create");
                }
-
                index++;
            }
+
+            if (self->body_height == 0 && index > 32)
+            {
+                /* Older font made for xrdp v0.9.x. Synthesise this
+                 * value from the first glyph */
+                self->body_height = -self->font_items[32].baseline + 1;
+            }
        }
    }

--- a/xrdp/xrdp_login_wnd.c
+++ b/xrdp/xrdp_login_wnd.c
@ -72,20 +72,32 @@ xrdp_wm_login_help_notify(struct xrdp_bitmap *wnd,

        if (p != 0)
        {
+            const int x = 10;
+            int y = xrdp_painter_font_body_height(p) * 2;
+            const int row_height = xrdp_painter_font_body_height(p);
+            const int end_para_height = row_height * 3 / 2;
+
            p->fg_color = wnd->wm->black;
-            xrdp_painter_draw_text(p, wnd, 10, 30, "You must be authenticated \
+            xrdp_painter_draw_text(p, wnd, x, y, "You must be authenticated \
 before using this");
-            xrdp_painter_draw_text(p, wnd, 10, 46, "session.");
-            xrdp_painter_draw_text(p, wnd, 10, 78, "Enter a valid username in \
+            y += row_height;
+            xrdp_painter_draw_text(p, wnd, x, y, "session.");
+            y += end_para_height;
+            xrdp_painter_draw_text(p, wnd, x, y, "Enter a valid username in \
 the username edit box.");
-            xrdp_painter_draw_text(p, wnd, 10, 94, "Enter the password in \
+            y += end_para_height;
+            xrdp_painter_draw_text(p, wnd, x, y, "Enter the password in \
 the password edit box.");
-            xrdp_painter_draw_text(p, wnd, 10, 110, "Both the username and \
+            y += end_para_height;
+            xrdp_painter_draw_text(p, wnd, x, y, "Both the username and \
 password are case");
-            xrdp_painter_draw_text(p, wnd, 10, 126, "sensitive.");
-            xrdp_painter_draw_text(p, wnd, 10, 158, "Contact your system \
+            y += row_height;
+            xrdp_painter_draw_text(p, wnd, x, y, "sensitive.");
+            y += end_para_height;
+            xrdp_painter_draw_text(p, wnd, x, y, "Contact your system \
 administrator if you are");
-            xrdp_painter_draw_text(p, wnd, 10, 174, "having problems \
+            y += row_height;
+            xrdp_painter_draw_text(p, wnd, x, y, "having problems \
 logging on.");
        }
    }
@ -147,9 +159,23 @@ xrdp_wm_help_clicked(struct xrdp_bitmap *wnd)
 {
    struct xrdp_bitmap *help;
    struct xrdp_bitmap *but;
+    const int width =
+        wnd->wm->xrdp_config->cfg_globals.ls_scaled.help_wnd_width;
+    const int height =
+        wnd->wm->xrdp_config->cfg_globals.ls_scaled.help_wnd_height;
+    const int ok_height =
+        wnd->wm->xrdp_config->cfg_globals.ls_scaled.default_btn_height;
+    const char *ok_string = "OK";
+
+    /* Get a width for the OK button */
+    struct xrdp_painter *p = xrdp_painter_create(wnd->wm, wnd->wm->session);
+    xrdp_painter_font_needed(p);
+    const int ok_width = xrdp_painter_text_width(p, ok_string) +
+                         DEFAULT_BUTTON_MARGIN_W;
+    xrdp_painter_delete(p);

    /* create help screen */
-    help = xrdp_bitmap_create(DEFAULT_WND_HELP_W, DEFAULT_WND_HELP_H, wnd->wm->screen->bpp,
+    help = xrdp_bitmap_create(width, height, wnd->wm->screen->bpp,
                              WND_TYPE_WND, wnd->wm);
    list_insert_item(wnd->wm->screen->child_list, 0, (long)help);
    help->parent = wnd->wm->screen;
@ -161,16 +187,16 @@ xrdp_wm_help_clicked(struct xrdp_bitmap *wnd)
    help->notify = xrdp_wm_login_help_notify;
    set_string(&help->caption1, "Login help");
    /* ok button */
-    but = xrdp_bitmap_create(DEFAULT_BUTTON_W, DEFAULT_BUTTON_H, wnd->wm->screen->bpp,
+    but = xrdp_bitmap_create(ok_width, ok_height, wnd->wm->screen->bpp,
                             WND_TYPE_BUTTON, wnd->wm);
    list_insert_item(help->child_list, 0, (long)but);
    but->parent = help;
    but->owner = help;
-    but->left = ((DEFAULT_WND_HELP_W / 2) - (DEFAULT_BUTTON_W / 2)); /* center */
-    but->top = DEFAULT_WND_HELP_H - DEFAULT_BUTTON_H - 15;
+    but->left = ((help->width / 2) - (ok_width / 2)); /* center */
+    but->top = help->height - ok_height - 15;
    but->id = 1;
    but->tab_stop = 1;
-    set_string(&but->caption1, "OK");
+    set_string(&but->caption1, ok_string);
    /* draw it */
    help->focused_control = but;
    help->default_button = but;
@ -387,32 +413,40 @@ xrdp_wm_show_edits(struct xrdp_wm *self, struct xrdp_bitmap *combo)
            }
            else if (g_strncmp(ASK, value, ASK_LEN) == 0)
            {
+                const int combo_height =
+                    self->xrdp_config->cfg_globals.ls_scaled.combo_height;
+                const int edit_height =
+                    self->xrdp_config->cfg_globals.ls_scaled.edit_height;
                /* label */
-                b = xrdp_bitmap_create(globals->ls_label_width, DEFAULT_EDIT_H, self->screen->bpp,
+                b = xrdp_bitmap_create(globals->ls_scaled.label_width,
+                                       edit_height, self->screen->bpp,
                                       WND_TYPE_LABEL, self);
                list_insert_item(self->login_window->child_list, insert_index,
                                 (long)b);
                insert_index++;
                b->parent = self->login_window;
                b->owner = self->login_window;
-                b->left = globals->ls_label_x_pos;
+                b->left = globals->ls_scaled.label_x_pos;

-                b->top = globals->ls_input_y_pos + DEFAULT_COMBO_H + 5 + (DEFAULT_EDIT_H + 5) * count;
+                b->top = globals->ls_scaled.input_y_pos + combo_height + 5 +
+                         (edit_height + 5) * count;
                b->id = 100 + 2 * count;
                name = (char *)list_get_item(mod->names, index);
                set_string(&b->caption1, name);

                /* edit */
-                b = xrdp_bitmap_create(globals->ls_input_width, DEFAULT_EDIT_H, self->screen->bpp,
+                b = xrdp_bitmap_create(globals->ls_scaled.input_width,
+                                       edit_height, self->screen->bpp,
                                       WND_TYPE_EDIT, self);
                list_insert_item(self->login_window->child_list, insert_index,
                                 (long)b);
                insert_index++;
                b->parent = self->login_window;
                b->owner = self->login_window;
-                b->left = globals->ls_input_x_pos;
+                b->left = globals->ls_scaled.input_x_pos;

-                b->top = globals->ls_input_y_pos + DEFAULT_COMBO_H + 5 + (DEFAULT_EDIT_H + 5) * count;
+                b->top = globals->ls_scaled.input_y_pos + combo_height + 5 +
+                         (edit_height + 5) * count;

                b->id = 100 + 2 * count + 1;
                b->pointer = 1;
@ -634,6 +668,81 @@ xrdp_wm_login_fill_in_combo(struct xrdp_wm *self, struct xrdp_bitmap *b)
    return 0;
 }

+/******************************************************************************/
+unsigned int
+xrdp_login_wnd_get_monitor_dpi(struct xrdp_wm *self)
+{
+    unsigned int result = 0;
+    const struct display_size_description *display_sizes =
+            &self->client_info->display_sizes;
+    unsigned int height_pixels = 0;
+    unsigned int height_mm = 0;
+
+    unsigned int i;
+
+    /* Look at the monitor data first */
+    for (i = 0; i < display_sizes->monitorCount; ++i)
+    {
+        const struct monitor_info *mi = &display_sizes->minfo_wm[i];
+        {
+            if (mi->is_primary)
+            {
+                height_pixels = mi->bottom - mi->top + 1;
+                height_mm = mi->physical_height;
+                break;
+            }
+        }
+    }
+
+    /* No primary monitor, or values not defined - use the desktop size */
+    if (height_mm == 0)
+    {
+        height_pixels = display_sizes->session_height;
+        height_mm = self->client_info->session_physical_height;
+
+        if (height_mm == 0)
+        {
+            LOG(LOG_LEVEL_WARNING,
+                "No information is available to determine login screen DPI");
+        }
+        else if (height_pixels < 768)
+        {
+            /* A bug was encountered with mstsc.exe version
+               10.0.19041.1682 where the full physical monitor size was
+               sent in TS_UD_CS_CORE when the desktop size was set to
+               less than the screen size.
+               To generate the bug, make a connection with a full-screen
+               single window, cancel the login, and reconnect at
+               (e.g.) 800x600.
+               We can't detect that exact situation here, but if the
+               session height is so small as to likely be in a window
+               (rather than full screen), we should ignore the physical
+               size */
+            LOG(LOG_LEVEL_WARNING,
+                "Ignoring unlikely physical session size %u "
+                "for height of %u pixels", height_mm, height_pixels);
+            height_mm = 0;
+        }
+    }
+
+    if (height_mm != 0)
+    {
+        /*
+         * DPI = height_pixels / (height_mm / 25.4)
+         *     = (height_pixels * 25.4) / height_mm
+         *     = (height_pixels * 127) / (height_mm * 5)
+         */
+        result = (height_pixels * 127 ) / (height_mm * 5);
+        LOG(LOG_LEVEL_INFO,
+            "Login screen monitor height is %u pixels over %u mm (%u DPI)",
+            height_pixels,
+            height_mm,
+            result);
+    }
+    return result;
+}
+
+
 /******************************************************************************/
 int
 xrdp_login_wnd_create(struct xrdp_wm *self)
@ -657,6 +766,10 @@ xrdp_login_wnd_create(struct xrdp_wm *self)
    int y;
    int cx;
    int cy;
+    const int combo_height =
+        self->xrdp_config->cfg_globals.ls_scaled.combo_height;
+    const int edit_height =
+        self->xrdp_config->cfg_globals.ls_scaled.edit_height;

    globals = &self->xrdp_config->cfg_globals;

@ -665,8 +778,8 @@ xrdp_login_wnd_create(struct xrdp_wm *self)
    primary_x_offset = primary_width / 2;
    primary_y_offset = primary_height / 2;

-    log_width = globals->ls_width;
-    log_height = globals->ls_height;
+    log_width = globals->ls_scaled.width;
+    log_height = globals->ls_scaled.height;
    regular = 1;

    if (self->screen->width < log_width)
@ -811,58 +924,61 @@ xrdp_login_wnd_create(struct xrdp_wm *self)
        xrdp_bitmap_load(but, globals->ls_logo_filename, self->palette,
                         globals->ls_bg_color,
                         globals->ls_logo_transform,
-                         globals->ls_logo_width,
-                         globals->ls_logo_height);
+                         globals->ls_scaled.logo_width,
+                         globals->ls_scaled.logo_height);
        but->parent = self->login_window;
        but->owner = self->login_window;
-        but->left = globals->ls_logo_x_pos;
-        but->top = globals->ls_logo_y_pos;
+        but->left = globals->ls_scaled.logo_x_pos;
+        but->top = globals->ls_scaled.logo_y_pos;
        list_add_item(self->login_window->child_list, (long)but);
    }

    /* label */
-    but = xrdp_bitmap_create(globals->ls_label_width, DEFAULT_EDIT_H, self->screen->bpp, WND_TYPE_LABEL, self);
+    but = xrdp_bitmap_create(globals->ls_scaled.label_width, edit_height,
+                             self->screen->bpp, WND_TYPE_LABEL, self);
    list_add_item(self->login_window->child_list, (long)but);
    but->parent = self->login_window;
    but->owner = self->login_window;
-    but->left = globals->ls_label_x_pos;
-    but->top = globals->ls_input_y_pos;
+    but->left = globals->ls_scaled.label_x_pos;
+    but->top = globals->ls_scaled.input_y_pos;
    set_string(&but->caption1, "Session");

    /* combo */
-    combo = xrdp_bitmap_create(globals->ls_input_width, DEFAULT_COMBO_H,
+    combo = xrdp_bitmap_create(globals->ls_scaled.input_width, combo_height,
                               self->screen->bpp, WND_TYPE_COMBO, self);
    list_add_item(self->login_window->child_list, (long)combo);
    combo->parent = self->login_window;
    combo->owner = self->login_window;
-    combo->left = globals->ls_input_x_pos;
-    combo->top = globals->ls_input_y_pos;
+    combo->left = globals->ls_scaled.input_x_pos;
+    combo->top = globals->ls_scaled.input_y_pos;
    combo->id = 6;
    combo->tab_stop = 1;
    xrdp_wm_login_fill_in_combo(self, combo);

    /* OK button */
-    but = xrdp_bitmap_create(globals->ls_btn_ok_width, globals->ls_btn_ok_height,
+    but = xrdp_bitmap_create(globals->ls_scaled.btn_ok_width,
+                             globals->ls_scaled.btn_ok_height,
                             self->screen->bpp, WND_TYPE_BUTTON, self);
    list_add_item(self->login_window->child_list, (long)but);
    but->parent = self->login_window;
    but->owner = self->login_window;
-    but->left = globals->ls_btn_ok_x_pos;
-    but->top = globals->ls_btn_ok_y_pos;
+    but->left = globals->ls_scaled.btn_ok_x_pos;
+    but->top = globals->ls_scaled.btn_ok_y_pos;
    but->id = 3;
    set_string(&but->caption1, "OK");
    but->tab_stop = 1;
    self->login_window->default_button = but;

    /* Cancel button */
-    but = xrdp_bitmap_create(globals->ls_btn_cancel_width,
-                             globals->ls_btn_cancel_height, self->screen->bpp,
+    but = xrdp_bitmap_create(globals->ls_scaled.btn_cancel_width,
+                             globals->ls_scaled.btn_cancel_height,
+                             self->screen->bpp,
                             WND_TYPE_BUTTON, self);
    list_add_item(self->login_window->child_list, (long)but);
    but->parent = self->login_window;
    but->owner = self->login_window;
-    but->left = globals->ls_btn_cancel_x_pos;
-    but->top = globals->ls_btn_cancel_y_pos;
+    but->left = globals->ls_scaled.btn_cancel_x_pos;
+    but->top = globals->ls_scaled.btn_cancel_y_pos;
    but->id = 2;
    set_string(&but->caption1, "Cancel");
    but->tab_stop = 1;
@ -948,27 +1064,39 @@ load_xrdp_config(struct xrdp_config *config, const char *xrdp_ini, int bpp)

    /* set default values in case we can't get them from xrdp.ini file */
    globals->ini_version = 1;
+    globals->default_dpi = 96;
+
    globals->ls_top_window_bg_color = HCOLOR(bpp, xrdp_wm_htoi("009cb5"));
    globals->ls_bg_color = HCOLOR(bpp, xrdp_wm_htoi("dedede"));
-    globals->ls_width = 350;
-    globals->ls_height = 350;
+    globals->ls_unscaled.width = 350;
+    globals->ls_unscaled.height = 350;
    globals->ls_background_transform = XBLT_NONE;
    globals->ls_logo_transform = XBLT_NONE;
-    globals->ls_logo_x_pos = 63;
-    globals->ls_logo_y_pos = 50;
-    globals->ls_label_x_pos = 30;
-    globals->ls_label_width = 65;
-    globals->ls_input_x_pos = 110;
-    globals->ls_input_width = 210;
-    globals->ls_input_y_pos = 150;
-    globals->ls_btn_ok_x_pos = 150;
-    globals->ls_btn_ok_y_pos = 300;
-    globals->ls_btn_ok_width = 85;
-    globals->ls_btn_ok_height = 30;
-    globals->ls_btn_cancel_x_pos = 245;
-    globals->ls_btn_cancel_y_pos = 300;
-    globals->ls_btn_cancel_width = 85;
-    globals->ls_btn_cancel_height = 30;
+    globals->ls_unscaled.logo_x_pos = 63;
+    globals->ls_unscaled.logo_y_pos = 50;
+    globals->ls_unscaled.label_x_pos = 30;
+    globals->ls_unscaled.label_width = 65;
+    globals->ls_unscaled.input_x_pos = 110;
+    globals->ls_unscaled.input_width = 210;
+    globals->ls_unscaled.input_y_pos = 150;
+    globals->ls_unscaled.btn_ok_x_pos = 150;
+    globals->ls_unscaled.btn_ok_y_pos = 300;
+    globals->ls_unscaled.btn_ok_width = 85;
+    globals->ls_unscaled.btn_ok_height = 30;
+    globals->ls_unscaled.btn_cancel_x_pos = 245;
+    globals->ls_unscaled.btn_cancel_y_pos = 300;
+    globals->ls_unscaled.btn_cancel_width = 85;
+    globals->ls_unscaled.btn_cancel_height = 30;
+    globals->ls_unscaled.default_btn_height =
+        DEFAULT_FONT_PIXEL_SIZE + DEFAULT_BUTTON_MARGIN_H;
+    globals->ls_unscaled.log_wnd_width = DEFAULT_WND_LOG_W;
+    globals->ls_unscaled.log_wnd_height = DEFAULT_WND_LOG_H;
+    globals->ls_unscaled.edit_height =
+        DEFAULT_FONT_PIXEL_SIZE + DEFAULT_EDIT_MARGIN_H;
+    globals->ls_unscaled.combo_height =
+        DEFAULT_FONT_PIXEL_SIZE + DEFAULT_COMBO_MARGIN_H;
+    globals->ls_unscaled.help_wnd_width = DEFAULT_WND_HELP_W;
+    globals->ls_unscaled.help_wnd_height = DEFAULT_WND_HELP_H;

    /* open xrdp.ini file */
    if ((fd = g_file_open(xrdp_ini)) < 0)
@ -1165,6 +1293,16 @@ load_xrdp_config(struct xrdp_config *config, const char *xrdp_ini, int bpp)
        }

        /* login screen values */
+        else if (g_strcmp(n, "default_dpi") == 0)
+        {
+            globals->default_dpi = g_atoi(v);
+        }
+
+        else if (g_strcmp(n, "fv1_select") == 0)
+        {
+            g_strncpy(globals->fv1_select, v, sizeof(globals->fv1_select) - 1);
+        }
+
        else if (g_strncmp(n, "ls_top_window_bg_color", 64) == 0)
        {
            globals->ls_top_window_bg_color = HCOLOR(bpp, xrdp_wm_htoi(v));
@ -1172,12 +1310,12 @@ load_xrdp_config(struct xrdp_config *config, const char *xrdp_ini, int bpp)

        else if (g_strncmp(n, "ls_width", 64) == 0)
        {
-            globals->ls_width = g_atoi(v);
+            globals->ls_unscaled.width = g_atoi(v);
        }

        else if (g_strncmp(n, "ls_height", 64) == 0)
        {
-            globals->ls_height = g_atoi(v);
+            globals->ls_unscaled.height = g_atoi(v);
        }

        else if (g_strncmp(n, "ls_bg_color", 64) == 0)
@ -1216,87 +1354,87 @@ load_xrdp_config(struct xrdp_config *config, const char *xrdp_ini, int bpp)

        else if (g_strncmp(n, "ls_logo_width", 64) == 0)
        {
-            globals->ls_logo_width = g_atoi(v);
+            globals->ls_unscaled.logo_width = g_atoi(v);
        }

        else if (g_strncmp(n, "ls_logo_height", 64) == 0)
        {
-            globals->ls_logo_height = g_atoi(v);
+            globals->ls_unscaled.logo_height = g_atoi(v);
        }

        else if (g_strncmp(n, "ls_logo_x_pos", 64) == 0)
        {
-            globals->ls_logo_x_pos = g_atoi(v);
+            globals->ls_unscaled.logo_x_pos = g_atoi(v);
        }

        else if (g_strncmp(n, "ls_logo_y_pos", 64) == 0)
        {
-            globals->ls_logo_y_pos = g_atoi(v);
+            globals->ls_unscaled.logo_y_pos = g_atoi(v);
        }

        else if (g_strncmp(n, "ls_label_x_pos", 64) == 0)
        {
-            globals->ls_label_x_pos = g_atoi(v);
+            globals->ls_unscaled.label_x_pos = g_atoi(v);
        }

        else if (g_strncmp(n, "ls_label_width", 64) == 0)
        {
-            globals->ls_label_width = g_atoi(v);
+            globals->ls_unscaled.label_width = g_atoi(v);
        }

        else if (g_strncmp(n, "ls_input_x_pos", 64) == 0)
        {
-            globals->ls_input_x_pos = g_atoi(v);
+            globals->ls_unscaled.input_x_pos = g_atoi(v);
        }

        else if (g_strncmp(n, "ls_input_width", 64) == 0)
        {
-            globals->ls_input_width = g_atoi(v);
+            globals->ls_unscaled.input_width = g_atoi(v);
        }

        else if (g_strncmp(n, "ls_input_y_pos", 64) == 0)
        {
-            globals->ls_input_y_pos = g_atoi(v);
+            globals->ls_unscaled.input_y_pos = g_atoi(v);
        }

        else if (g_strncmp(n, "ls_btn_ok_x_pos", 64) == 0)
        {
-            globals->ls_btn_ok_x_pos = g_atoi(v);
+            globals->ls_unscaled.btn_ok_x_pos = g_atoi(v);
        }

        else if (g_strncmp(n, "ls_btn_ok_y_pos", 64) == 0)
        {
-            globals->ls_btn_ok_y_pos = g_atoi(v);
+            globals->ls_unscaled.btn_ok_y_pos = g_atoi(v);
        }

        else if (g_strncmp(n, "ls_btn_ok_width", 64) == 0)
        {
-            globals->ls_btn_ok_width = g_atoi(v);
+            globals->ls_unscaled.btn_ok_width = g_atoi(v);
        }

        else if (g_strncmp(n, "ls_btn_ok_height", 64) == 0)
        {
-            globals->ls_btn_ok_height = g_atoi(v);
+            globals->ls_unscaled.btn_ok_height = g_atoi(v);
        }

        else if (g_strncmp(n, "ls_btn_cancel_x_pos", 64) == 0)
        {
-            globals->ls_btn_cancel_x_pos = g_atoi(v);
+            globals->ls_unscaled.btn_cancel_x_pos = g_atoi(v);
        }

        else if (g_strncmp(n, "ls_btn_cancel_y_pos", 64) == 0)
        {
-            globals->ls_btn_cancel_y_pos = g_atoi(v);
+            globals->ls_unscaled.btn_cancel_y_pos = g_atoi(v);
        }

        else if (g_strncmp(n, "ls_btn_cancel_width", 64) == 0)
        {
-            globals->ls_btn_cancel_width = g_atoi(v);
+            globals->ls_unscaled.btn_cancel_width = g_atoi(v);
        }

        else if (g_strncmp(n, "ls_btn_cancel_height", 64) == 0)
        {
-            globals->ls_btn_cancel_height = g_atoi(v);
+            globals->ls_unscaled.btn_cancel_height = g_atoi(v);
        }
    }

@ -1335,29 +1473,95 @@ load_xrdp_config(struct xrdp_config *config, const char *xrdp_ini, int bpp)
    LOG(LOG_LEVEL_DEBUG, "enable_token_login:      %d", globals->enable_token_login);

    LOG(LOG_LEVEL_DEBUG, "ls_top_window_bg_color:  %x", globals->ls_top_window_bg_color);
-    LOG(LOG_LEVEL_DEBUG, "ls_width:                %d", globals->ls_width);
-    LOG(LOG_LEVEL_DEBUG, "ls_height:               %d", globals->ls_height);
+    LOG(LOG_LEVEL_DEBUG, "ls_width (unscaled):     %d", globals->ls_unscaled.width);
+    LOG(LOG_LEVEL_DEBUG, "ls_height (unscaled):    %d", globals->ls_unscaled.height);
    LOG(LOG_LEVEL_DEBUG, "ls_bg_color:             %x", globals->ls_bg_color);
    LOG(LOG_LEVEL_DEBUG, "ls_title:                %s", globals->ls_title);
    LOG(LOG_LEVEL_DEBUG, "ls_logo_filename:        %s", globals->ls_logo_filename);
-    LOG(LOG_LEVEL_DEBUG, "ls_logo_x_pos:           %d", globals->ls_logo_x_pos);
-    LOG(LOG_LEVEL_DEBUG, "ls_logo_y_pos:           %d", globals->ls_logo_y_pos);
-    LOG(LOG_LEVEL_DEBUG, "ls_label_x_pos:          %d", globals->ls_label_x_pos);
-    LOG(LOG_LEVEL_DEBUG, "ls_label_width:          %d", globals->ls_label_width);
-    LOG(LOG_LEVEL_DEBUG, "ls_input_x_pos:          %d", globals->ls_input_x_pos);
-    LOG(LOG_LEVEL_DEBUG, "ls_input_width:          %d", globals->ls_input_width);
-    LOG(LOG_LEVEL_DEBUG, "ls_input_y_pos:          %d", globals->ls_input_y_pos);
-    LOG(LOG_LEVEL_DEBUG, "ls_btn_ok_x_pos:         %d", globals->ls_btn_ok_x_pos);
-    LOG(LOG_LEVEL_DEBUG, "ls_btn_ok_y_pos:         %d", globals->ls_btn_ok_y_pos);
-    LOG(LOG_LEVEL_DEBUG, "ls_btn_ok_width:         %d", globals->ls_btn_ok_width);
-    LOG(LOG_LEVEL_DEBUG, "ls_btn_ok_height:        %d", globals->ls_btn_ok_height);
-    LOG(LOG_LEVEL_DEBUG, "ls_btn_cancel_x_pos:     %d", globals->ls_btn_cancel_x_pos);
-    LOG(LOG_LEVEL_DEBUG, "ls_btn_cancel_y_pos:     %d", globals->ls_btn_cancel_y_pos);
-    LOG(LOG_LEVEL_DEBUG, "ls_btn_cancel_width:     %d", globals->ls_btn_cancel_width);
-    LOG(LOG_LEVEL_DEBUG, "ls_btn_cancel_height:    %d", globals->ls_btn_cancel_height);
+    LOG(LOG_LEVEL_DEBUG, "ls_logo_x_pos :          %d", globals->ls_unscaled.logo_x_pos);
+    LOG(LOG_LEVEL_DEBUG, "ls_logo_y_pos :          %d", globals->ls_unscaled.logo_y_pos);
+    LOG(LOG_LEVEL_DEBUG, "ls_label_x_pos :         %d", globals->ls_unscaled.label_x_pos);
+    LOG(LOG_LEVEL_DEBUG, "ls_label_width :         %d", globals->ls_unscaled.label_width);
+    LOG(LOG_LEVEL_DEBUG, "ls_input_x_pos :         %d", globals->ls_unscaled.input_x_pos);
+    LOG(LOG_LEVEL_DEBUG, "ls_input_width :         %d", globals->ls_unscaled.input_width);
+    LOG(LOG_LEVEL_DEBUG, "ls_input_y_pos :         %d", globals->ls_unscaled.input_y_pos);
+    LOG(LOG_LEVEL_DEBUG, "ls_btn_ok_x_pos :        %d", globals->ls_unscaled.btn_ok_x_pos);
+    LOG(LOG_LEVEL_DEBUG, "ls_btn_ok_y_pos :        %d", globals->ls_unscaled.btn_ok_y_pos);
+    LOG(LOG_LEVEL_DEBUG, "ls_btn_ok_width :        %d", globals->ls_unscaled.btn_ok_width);
+    LOG(LOG_LEVEL_DEBUG, "ls_btn_ok_height :       %d", globals->ls_unscaled.btn_ok_height);
+    LOG(LOG_LEVEL_DEBUG, "ls_btn_cancel_x_pos :    %d", globals->ls_unscaled.btn_cancel_x_pos);
+    LOG(LOG_LEVEL_DEBUG, "ls_btn_cancel_y_pos :    %d", globals->ls_unscaled.btn_cancel_y_pos);
+    LOG(LOG_LEVEL_DEBUG, "ls_btn_cancel_width :    %d", globals->ls_unscaled.btn_cancel_width);
+    LOG(LOG_LEVEL_DEBUG, "ls_btn_cancel_height :   %d", globals->ls_unscaled.btn_cancel_height);

    list_delete(names);
    list_delete(values);
    g_file_close(fd);
    return 0;
 }
+
+/**
+ * Scale the configuration values
+ *
+ * After a font has been loaded, we can produce scaled versions of the
+ * login screen layout parameters which will correspond to the size of the
+ * font
+ */
+void
+xrdp_login_wnd_scale_config_values(struct xrdp_wm *self)
+{
+    const struct xrdp_ls_dimensions *unscaled =
+            &self->xrdp_config->cfg_globals.ls_unscaled;
+    struct xrdp_ls_dimensions *scaled =
+            &self->xrdp_config->cfg_globals.ls_scaled;
+
+    /* Clear the scaled values, so if we add one and forget to scale it,
+     * it will be obvious */
+    g_memset(scaled, '\0', sizeof(*scaled));
+
+    /* If we don't have a font, use zeros for everything */
+    if (self->default_font == NULL)
+    {
+        LOG(LOG_LEVEL_ERROR, "Can't scale login values - no font available");
+    }
+    else
+    {
+        const int fheight = self->default_font->body_height;
+        /* Define a Macro to scale to the nearest pixel value,
+         * rounding up as appropriate */
+#define SCALE_AND_ROUND(x) \
+    (((x) * fheight + (DEFAULT_FONT_PIXEL_SIZE / 2)) / \
+     DEFAULT_FONT_PIXEL_SIZE)
+
+        LOG(LOG_LEVEL_DEBUG, "Login screen scale factor %f",
+            (float)fheight / DEFAULT_FONT_PIXEL_SIZE);
+
+        scaled->width = SCALE_AND_ROUND(unscaled->width);
+        scaled->height = SCALE_AND_ROUND(unscaled->height);
+        scaled->logo_width = SCALE_AND_ROUND(unscaled->logo_width);
+        scaled->logo_height = SCALE_AND_ROUND(unscaled->logo_height);
+        scaled->logo_x_pos = SCALE_AND_ROUND(unscaled->logo_x_pos);
+        scaled->logo_y_pos = SCALE_AND_ROUND(unscaled->logo_y_pos);
+        scaled->label_x_pos = SCALE_AND_ROUND(unscaled->label_x_pos);
+        scaled->label_width = SCALE_AND_ROUND(unscaled->label_width);
+        scaled->input_x_pos = SCALE_AND_ROUND(unscaled->input_x_pos);
+        scaled->input_width = SCALE_AND_ROUND(unscaled->input_width);
+        scaled->input_y_pos = SCALE_AND_ROUND(unscaled->input_y_pos);
+        scaled->btn_ok_x_pos = SCALE_AND_ROUND(unscaled->btn_ok_x_pos);
+        scaled->btn_ok_y_pos = SCALE_AND_ROUND(unscaled->btn_ok_y_pos);
+        scaled->btn_ok_width = SCALE_AND_ROUND(unscaled->btn_ok_width);
+        scaled->btn_ok_height = SCALE_AND_ROUND(unscaled->btn_ok_height);
+        scaled->btn_cancel_x_pos = SCALE_AND_ROUND(unscaled->btn_cancel_x_pos);
+        scaled->btn_cancel_y_pos = SCALE_AND_ROUND(unscaled->btn_cancel_y_pos);
+        scaled->btn_cancel_width = SCALE_AND_ROUND(unscaled->btn_cancel_width);
+        scaled->btn_cancel_height = SCALE_AND_ROUND(unscaled->btn_cancel_height);
+        scaled->default_btn_height = fheight + DEFAULT_BUTTON_MARGIN_H;
+        scaled->log_wnd_width = SCALE_AND_ROUND(unscaled->log_wnd_width);
+        scaled->log_wnd_height = SCALE_AND_ROUND(unscaled->log_wnd_height);
+        scaled->edit_height = fheight + DEFAULT_EDIT_MARGIN_H;
+        scaled->combo_height = fheight + DEFAULT_COMBO_MARGIN_H;
+        scaled->help_wnd_width = SCALE_AND_ROUND(unscaled->help_wnd_width);
+        scaled->help_wnd_height = SCALE_AND_ROUND(unscaled->help_wnd_height);
+#undef SCALE_AND_ROUND
+    }
+}
--- a/xrdp/xrdp_painter.c
+++ b/xrdp/xrdp_painter.c
@ -30,7 +30,6 @@
 #endif


-
 #if defined(XRDP_PAINTER)

 /*****************************************************************************/
@ -464,41 +463,10 @@ xrdp_painter_text_width(struct xrdp_painter *self, const char *text)
 }

 /*****************************************************************************/
-int
-xrdp_painter_text_height(struct xrdp_painter *self, const char *text)
+unsigned int
+xrdp_painter_font_body_height(const struct xrdp_painter *self)
 {
-    int index;
-    int rv;
-    int len;
-    struct xrdp_font_char *font_item;
-    twchar *wstr;
-
-    LOG_DEVEL(LOG_LEVEL_DEBUG, "xrdp_painter_text_height:");
-    xrdp_painter_font_needed(self);
-
-    if (self->font == 0)
-    {
-        return 0;
-    }
-
-    if (text == 0)
-    {
-        return 0;
-    }
-
-    rv = 0;
-    len = g_mbstowcs(0, text, 0);
-    wstr = (twchar *)g_malloc((len + 2) * sizeof(twchar), 0);
-    g_mbstowcs(wstr, text, len + 1);
-
-    for (index = 0; index < len; index++)
-    {
-        font_item = self->font->font_items + wstr[index];
-        rv = MAX(rv, font_item->height);
-    }
-
-    g_free(wstr);
-    return rv;
+    return (self->font == NULL) ? 0 : self->font->body_height;
 }

 /*****************************************************************************/
@ -830,7 +798,6 @@ xrdp_painter_draw_text(struct xrdp_painter *self,
        return 0;
    }

-
    len = g_mbstowcs(0, text, 0);

    if (len < 1)
@ -873,7 +840,11 @@ xrdp_painter_draw_text(struct xrdp_painter *self,
                font_item = font->font_items + wstr[index];
                k = font_item->incby;
                total_width += k;
-                total_height = MAX(total_height, font_item->height);
+                /* Use the nominal height of the font to work out the
+                 * actual height of this glyph */
+                int glyph_height =
+                    font->body_height + font_item->baseline + font_item->height;
+                total_height = MAX(total_height, glyph_height);
            }
            xrdp_bitmap_get_screen_clip(dst, self, &clip_rect, &dx, &dy);
            region = xrdp_region_create(self->wm);
@ -912,12 +883,12 @@ xrdp_painter_draw_text(struct xrdp_painter *self,
                        pat.height = font_item->height;
                        pat.data = font_item->data;
                        x1 = x + font_item->offset;
-                        y1 = y + (font_item->height + font_item->baseline);
+                        y1 = y + (font->body_height + font_item->baseline);
                        painter_fill_pattern(self->painter, &dst_pb, &pat,
                                             0, 0, x1, y1,
                                             font_item->width,
                                             font_item->height);
-                        xrdp_painter_add_dirty_rect(self, x, y,
+                        xrdp_painter_add_dirty_rect(self, x1, y1,
                                                    font_item->width,
                                                    font_item->height,
                                                    &draw_rect);
@ -954,7 +925,11 @@ xrdp_painter_draw_text(struct xrdp_painter *self,
        data[index * 2 + 1] = k;
        k = font_item->incby;
        total_width += k;
-        total_height = MAX(total_height, font_item->height);
+        /* Use the nominal height of the font to work out the
+         * actual height of this glyph */
+        int glyph_height =
+            font->body_height + font_item->baseline + font_item->height;
+        total_height = MAX(total_height, glyph_height);
    }

    xrdp_bitmap_get_screen_clip(dst, self, &clip_rect, &dx, &dy);
@ -979,7 +954,7 @@ xrdp_painter_draw_text(struct xrdp_painter *self,
        if (rect_intersect(&rect, &clip_rect, &draw_rect))
        {
            x1 = x;
-            y1 = y + total_height;
+            y1 = y + font->body_height;
            flags = 0x03; /* 0x03 0x73; TEXT2_IMPLICIT_X and something else */
            libxrdp_orders_text(self->session, f, flags, 0,
                                self->fg_color, 0,
--- a/xrdp/xrdp_types.h
+++ b/xrdp/xrdp_types.h
@ -605,12 +605,13 @@ struct xrdp_bitmap

 #define NUM_FONTS 0x4e00
 #define DEFAULT_FONT_NAME "sans-10.fv1"
+#define DEFAULT_FONT_PIXEL_SIZE 16
+#define DEFAULT_FV1_SELECT "130:sans-18.fv1,0:" DEFAULT_FONT_NAME

-#define DEFAULT_ELEMENT_TOP   35
-#define DEFAULT_BUTTON_W      60
-#define DEFAULT_BUTTON_H      23
-#define DEFAULT_COMBO_H       21
-#define DEFAULT_EDIT_H        21
+#define DEFAULT_BUTTON_MARGIN_H 12
+#define DEFAULT_BUTTON_MARGIN_W 12
+#define DEFAULT_COMBO_MARGIN_H 6
+#define DEFAULT_EDIT_MARGIN_H  6
 #define DEFAULT_WND_LOGIN_W   425
 #define DEFAULT_WND_LOGIN_H   475
 #define DEFAULT_WND_HELP_W    340
@ -626,6 +627,8 @@ struct xrdp_font
    struct xrdp_font_char font_items[NUM_FONTS];
    char name[32];
    int size;
+    /** Body height in pixels */
+    int body_height;
    int style;
 };

@ -655,9 +658,39 @@ struct xrdp_startup_params
 };

 /*
- * For storing xrdp.ini configuration settings
+ * For storing xrdp.ini (and other) configuration settings
 */

+struct xrdp_ls_dimensions
+{
+    int  width;               /* window width */
+    int  height;              /* window height */
+    int  logo_width;          /* logo width (optional) */
+    int  logo_height;          /* logo height (optional) */
+    int  logo_x_pos;          /* logo x co-ordinate */
+    int  logo_y_pos;          /* logo y co-ordinate */
+    int  label_x_pos;         /* x pos of labels */
+    int  label_width;         /* width of labels */
+    int  input_x_pos;         /* x pos of text and combo boxes */
+    int  input_width;         /* width of input and combo boxes */
+    int  input_y_pos;         /* y pos for for first label and combo box */
+    int  btn_ok_x_pos;        /* x pos for OK button */
+    int  btn_ok_y_pos;        /* y pos for OK button */
+    int  btn_ok_width;        /* width of OK button */
+    int  btn_ok_height;       /* height of OK button */
+    int  btn_cancel_x_pos;    /* x pos for Cancel button */
+    int  btn_cancel_y_pos;    /* y pos for Cancel button */
+    int  btn_cancel_width;    /* width of Cancel button */
+    int  btn_cancel_height;   /* height of Cancel button */
+    int default_btn_height;   /* Default button height (e.g. OK on login box) */
+    int log_wnd_width;        /* Width of log window */
+    int log_wnd_height;       /* Height of log window */
+    int edit_height;          /* Height of an edit box */
+    int combo_height;         /* Height of a combo box */
+    int help_wnd_width;        /* Width of login help window */
+    int help_wnd_height;       /* Height of login help window */
+};
+
 struct xrdp_cfg_globals
 {
    int  ini_version;            /* xrdp.ini file version number */
@ -694,34 +727,21 @@ struct xrdp_cfg_globals
    int  background;

    /* login screen */
+    unsigned int  default_dpi;   /* Default DPI to use if nothing from client */
+    char fv1_select[256];        /* Selection string for fv1 font */
    int  ls_top_window_bg_color; /* top level window background color */
-    int  ls_width;               /* window width */
-    int  ls_height;              /* window height */
    int  ls_bg_color;            /* background color */
    char ls_background_image[256];  /* background image file name */
-    enum xrdp_bitmap_load_transform ls_background_transform;
    /* transform to apply to background image */
+    enum xrdp_bitmap_load_transform ls_background_transform;
    char ls_logo_filename[256];  /* logo filename */
-    enum xrdp_bitmap_load_transform ls_logo_transform;
    /* transform to apply to logo */
-    int  ls_logo_width;          /* logo width (optional) */
-    int  ls_logo_height;          /* logo height (optional) */
-    int  ls_logo_x_pos;          /* logo x coordinate */
-    int  ls_logo_y_pos;          /* logo y coordinate */
-    int  ls_label_x_pos;         /* x pos of labels */
-    int  ls_label_width;         /* width of labels */
-    int  ls_input_x_pos;         /* x pos of text and combo boxes */
-    int  ls_input_width;         /* width of input and combo boxes */
-    int  ls_input_y_pos;         /* y pos for for first label and combo box */
-    int  ls_btn_ok_x_pos;        /* x pos for OK button */
-    int  ls_btn_ok_y_pos;        /* y pos for OK button */
-    int  ls_btn_ok_width;        /* width of OK button */
-    int  ls_btn_ok_height;       /* height of OK button */
-    int  ls_btn_cancel_x_pos;    /* x pos for Cancel button */
-    int  ls_btn_cancel_y_pos;    /* y pos for Cancel button */
-    int  ls_btn_cancel_width;    /* width of Cancel button */
-    int  ls_btn_cancel_height;   /* height of Cancel button */
+    enum xrdp_bitmap_load_transform ls_logo_transform;
    char ls_title[256];          /* loginscreen window title */
+    /* Login screen dimensions, unscaled (from config) */
+    struct xrdp_ls_dimensions ls_unscaled;
+    /* Login screen dimensions, scaled (after font is loaded) */
+    struct xrdp_ls_dimensions ls_scaled;
 };

 struct xrdp_cfg_logging
--- a/xrdp/xrdp_wm.c
+++ b/xrdp/xrdp_wm.c
@ -62,7 +62,6 @@ xrdp_wm_create(struct xrdp_process *owner,
    self->log = list_create();
    self->log->auto_free = 1;
    self->mm = xrdp_mm_create(self);
-    self->default_font = xrdp_font_create(self);
    /* this will use built in keymap or load from file */
    get_keymaps(self->session->client_info->keylayout, &(self->keymap));
    xrdp_wm_set_login_state(self, WMLS_RESET);
@ -570,12 +569,20 @@ xrdp_wm_init(struct xrdp_wm *self)
    char default_section_name[256];
    char section_name[256];
    char autorun_name[256];
+    int dpi;

    LOG(LOG_LEVEL_DEBUG, "in xrdp_wm_init: ");

    load_xrdp_config(self->xrdp_config, self->session->xrdp_ini,
                     self->screen->bpp);

+    /* Load the font */
+    dpi = xrdp_login_wnd_get_monitor_dpi(self);
+    self->default_font = xrdp_font_create(self, dpi);
+
+    /* Scale the login screen values */
+    xrdp_login_wnd_scale_config_values(self);
+
    /* global channels allow */
    names = list_create();
    names->auto_free = 1;
@ -2047,12 +2054,14 @@ xrdp_wm_log_wnd_notify(struct xrdp_bitmap *wnd,

        if (painter != 0)
        {
+            unsigned int row_height = xrdp_painter_font_body_height(painter);
            painter->fg_color = wnd->wm->black;

            for (index = 0; index < wnd->wm->log->count; index++)
            {
                text = (char *)list_get_item(wnd->wm->log, index);
-                xrdp_painter_draw_text(painter, wnd, 10, 30 + index * 15, text);
+                xrdp_painter_draw_text(painter, wnd, 10,
+                                       (index  + 2) * row_height, text);
            }
        }
    }
@ -2102,8 +2111,9 @@ xrdp_wm_show_log(struct xrdp_wm *self)

    if (self->log_wnd == 0)
    {
-        w = DEFAULT_WND_LOG_W;
-        h = DEFAULT_WND_LOG_H;
+        w = self->xrdp_config->cfg_globals.ls_scaled.log_wnd_width;
+        h = self->xrdp_config->cfg_globals.ls_scaled.log_wnd_height;
+
        xoffset = 10;
        yoffset = 10;

@ -2147,12 +2157,19 @@ xrdp_wm_show_log(struct xrdp_wm *self)
        self->log_wnd->top = primary_y_offset + yoffset;
        set_string(&(self->log_wnd->caption1), "Connection Log");
        /* ok button */
-        but = xrdp_bitmap_create(DEFAULT_BUTTON_W, DEFAULT_BUTTON_H, self->screen->bpp, WND_TYPE_BUTTON, self);
+        const char *ok_string = "OK";
+        const int ok_height =
+            self->xrdp_config->cfg_globals.ls_scaled.default_btn_height;
+        const int ok_width = xrdp_painter_text_width(self->painter, ok_string) +
+                             DEFAULT_BUTTON_MARGIN_W;
+
+        but = xrdp_bitmap_create(ok_width, ok_height, self->screen->bpp,
+                                 WND_TYPE_BUTTON, self);
        list_insert_item(self->log_wnd->child_list, 0, (long)but);
        but->parent = self->log_wnd;
        but->owner = self->log_wnd;
-        but->left = (w - DEFAULT_BUTTON_W) - xoffset;
-        but->top = (h - DEFAULT_BUTTON_H) - yoffset;
+        but->left = (w - ok_width) - xoffset;
+        but->top = (h - ok_height) - yoffset;
        but->id = 1;
        but->tab_stop = 1;
        set_string(&but->caption1, "OK");