Add complete memory font loading API for FLTK

- Add memory font loading API for Windows, macOS, X11, and Cairo/Pango support
- Fix code review issues: secure temp files, error handling, avoid clearing all fonts
- Add missing flstring.h include for fl_strdup() in Cairo driver
- Remove fontconfig dependency from Cairo driver, use only FreeType for memory fonts
- Add comprehensive test for loading font from memory

This implementation provides a unified API across all platforms for loading
fonts directly from memory buffers, improving font handling capabilities
in FLTK applications.

Author: MatthiasWM

FL/Fl.H

@@ -663,6 +663,65 @@ FL_EXPORT extern void set_font(Fl_Font, Fl_Font);
 */
 FL_EXPORT extern Fl_Font set_fonts(const char* = 0); // platform dependent
 
+/**
+  Load a font from a TrueType or OpenType font file in memory and make it
+  available for use by FLTK.
+
+  This function loads font data directly from memory, which is useful for
+  embedding fonts in applications or loading fonts from custom sources without
+  requiring them to be installed on the system.
+
+  \param[in] data       Pointer to the font data in memory. The data must be in a
+                        valid TrueType (.ttf) or OpenType (.otf) format.
+  \param[in] data_size  Size of the font data in bytes.
+  \param[in] font_name  The name under which this font will be registered and can
+                        be accessed. If NULL, the font's embedded name will be
+                        used if available.
+
+  \return The font number (Fl_Font) that can be used with fl_font() and other
+          font functions. Returns -1 (cast to Fl_Font) if the font could not be
+          loaded. The returned font number is at or above FL_FREE_FONT.
+
+  \note The font data must remain valid for as long as the font is in use.
+        FLTK does not copy the data; it keeps a reference to it.
+  \note Platform support:
+        - Windows: Uses AddFontMemResourceEx (GDI)
+        - macOS: Uses CTFontManagerRegisterGraphicsFont (CoreText)
+        - Linux/Unix with Pango: Uses FreeType2 FT_New_Memory_Face
+        - Linux/Unix with Xft: Uses FreeType2 FT_New_Memory_Face
+        - Other platforms: May not be supported; returns -1
+
+  Example:
+  \code
+  // Load a font embedded in the application
+  extern unsigned char my_font_data[];
+  extern unsigned int my_font_data_size;
+
+  Fl_Font my_font = Fl::load_font(my_font_data, my_font_data_size, "MyCustomFont");
+  if (my_font != (Fl_Font)-1) {
+    fl_font(my_font, 14);
+    fl_draw("Hello with custom font!", 10, 30);
+  }
+  \endcode
+*/
+FL_EXPORT extern Fl_Font load_font(const void* data, size_t data_size,
+                                   const char* font_name = nullptr);
+
+/**
+  Unload a font that was previously loaded with load_font().
+
+  This function frees the resources associated with a font that was loaded
+  from memory. After calling this function, the font number should no longer
+  be used.
+
+  \param[in] font  The font number returned by load_font().
+
+  \note The original font data memory can be freed after calling this function.
+  \note This function does nothing if the font was not loaded via load_font()
+        or if the font number is invalid.
+*/
+FL_EXPORT extern void unload_font(Fl_Font font);
+
 /**   @} */
 
 /** \defgroup  fl_drawings  Drawing functions

FL/Fl_Graphics_Driver.H

@@ -364,6 +364,10 @@ public:
   virtual unsigned font_desc_size();
   virtual const char *font_name(int num);
   virtual void font_name(int num, const char *name);
+  /** Load a font from memory. Returns font number on success, or (Fl_Font)-1 on failure. */
+  virtual Fl_Font load_font(const void* data, size_t data_size, const char* font_name);
+  /** Unload a font previously loaded with load_font(). */
+  virtual void unload_font(Fl_Font font);
   // Defaut implementation may be enough
   virtual void overlay_rect(int x, int y, int w , int h);
   virtual float override_scale();

src/CMakeLists.txt

@@ -768,13 +768,23 @@ if(USE_PANGO)
   if(USE_PANGOXFT)
     append_optional_libs(PkgConfig::PANGOXFT)
   endif(USE_PANGOXFT)
+  # Add FreeType library for memory font loading support in Cairo driver
+  find_library(LIB_freetype freetype)
+  if(LIB_freetype)
+    list(APPEND OPTIONAL_LIBS ${LIB_freetype})
+  endif(LIB_freetype)
 endif(USE_PANGO)
 
 if(USE_XFT)
   list(APPEND OPTIONAL_LIBS ${X11_Xft_LIB})
   if(LIB_fontconfig)
     list(APPEND OPTIONAL_LIBS ${LIB_fontconfig})
   endif(LIB_fontconfig)
+  # Add FreeType library for memory font loading support
+  find_library(LIB_freetype freetype)
+  if(LIB_freetype)
+    list(APPEND OPTIONAL_LIBS ${LIB_freetype})
+  endif(LIB_freetype)
 endif(USE_XFT)
 
 if(UNIX AND FLTK_USE_WAYLAND)

src/Fl_Graphics_Driver.cxx

@@ -755,6 +755,23 @@ const char *Fl_Graphics_Driver::font_name(int num) {return NULL;}
 /** Support for Fl::set_font() */
 void Fl_Graphics_Driver::font_name(int num, const char *name) {}
 
+/**
+  Default implementation of load_font().
+  Platform-specific graphics drivers should override this method.
+  \returns (Fl_Font)-1 to indicate that loading fonts from memory is not supported.
+*/
+Fl_Font Fl_Graphics_Driver::load_font(const void* /*data*/, size_t /*data_size*/, const char* /*font_name*/) {
+  return (Fl_Font)-1;
+}
+
+/**
+  Default implementation of unload_font().
+  Platform-specific graphics drivers should override this method.
+*/
+void Fl_Graphics_Driver::unload_font(Fl_Font /*font*/) {
+  // Default implementation does nothing
+}
+
 /** Support function for fl_overlay_rect() and scaled GUI.*/
 void Fl_Graphics_Driver::overlay_rect(int x, int y, int w , int h) {
   loop(x, y, x+w-1, y, x+w-1, y+h-1, x, y+h-1);

src/Fl_Scalable_Graphics_Driver.H

@@ -150,6 +150,10 @@ struct Fl_Fontdesc {
   const char *name;
   char fontname[128];  // "Pretty" font name
   Fl_Font_Descriptor *first;  // linked list of sizes of this style
+  // Memory font support
+  const void *mem_font_data;  // Pointer to font data in memory (NULL for system fonts)
+  size_t mem_font_size;       // Size of memory font data
+  void *mem_font_handle;      // Platform-specific handle for the memory font
 };
 
 #endif // FL_DOXYGEN

src/drivers/Cairo/Fl_Cairo_Graphics_Driver.H

@@ -186,6 +186,8 @@ public:
   void font_name(int num, const char *name) FL_OVERRIDE;
   const char* get_font_name(Fl_Font fnum, int* ap) FL_OVERRIDE;
   int get_font_sizes(Fl_Font fnum, int*& sizep) FL_OVERRIDE;
+  Fl_Font load_font(const void* data, size_t data_size, const char* font_name) FL_OVERRIDE;
+  void unload_font(Fl_Font font) FL_OVERRIDE;
   Fl_Region XRectangleRegion(int x, int y, int w, int h) FL_OVERRIDE;
   void XDestroyRegion(Fl_Region r) FL_OVERRIDE;
   void add_rectangle_to_region(Fl_Region r, int X, int Y, int W, int H) FL_OVERRIDE;

src/drivers/Cairo/Fl_Cairo_Graphics_Driver.cxx

@@ -1570,4 +1570,117 @@ cairo_pattern_t *Fl_Cairo_Graphics_Driver::calc_cairo_mask(const Fl_RGB_Image *r
   return mask_pattern;
 }
 
+// Memory font loading for Cairo/Pango using FreeType
+// This implementation uses FreeType to parse font data and extract the font family name.
+// The font is then registered with FLTK's font table for use with Pango.
+
+#include "../../flstring.h" // for fl_strdup()
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include <stdlib.h>  // for free()
+
+/**
+  Load a TrueType or OpenType font from memory.
+  
+  The font data is parsed using FreeType to extract the font family name,
+  which is then registered with FLTK's font table.
+  
+  \param data Pointer to the font data in memory (TrueType or OpenType format).
+  \param data_size Size of the font data in bytes.
+  \param font_name Name to register the font with, or NULL to use the embedded name.
+  \return Font number on success, or (Fl_Font)-1 on failure.
+  
+  \note The font data buffer must remain valid while the font is in use.
+*/
+Fl_Font Fl_Cairo_Graphics_Driver::load_font(const void* data, size_t data_size, const char* font_name) {
+  if (!data || data_size == 0) return (Fl_Font)-1;
+
+  fl_open_display();
+
+  // Create a FreeType library instance for font parsing
+  FT_Library ft_library;
+  if (FT_Init_FreeType(&ft_library) != 0) {
+    return (Fl_Font)-1;
+  }
+
+  // Create a face from the memory buffer to extract font information
+  FT_Face ft_face;
+  if (FT_New_Memory_Face(ft_library, (const FT_Byte*)data, (FT_Long)data_size, 0, &ft_face) != 0) {
+    FT_Done_FreeType(ft_library);
+    return (Fl_Font)-1;
+  }
+
+  // Get the font family name if not provided
+  const char* name_to_use = font_name;
+  if (!name_to_use && ft_face->family_name) {
+    name_to_use = ft_face->family_name;
+  }
+
+  if (!name_to_use) {
+    FT_Done_Face(ft_face);
+    FT_Done_FreeType(ft_library);
+    return (Fl_Font)-1;
+  }
+
+  // For Pango, use full font name without prefix
+  char* allocated_name = fl_strdup(name_to_use);
+
+  FT_Done_Face(ft_face);
+  FT_Done_FreeType(ft_library);
+
+  if (!allocated_name) {
+    return (Fl_Font)-1;
+  }
+
+  // Find a free font slot
+  Fl_Font fnum = Fl::set_fonts(NULL);
+  if (fnum == 0) fnum = FL_FREE_FONT;
+
+  // Register the font in FLTK's table
+  Fl::set_font(fnum, allocated_name);
+
+  // Store the memory font information
+  unsigned width = font_desc_size();
+  Fl_Fontdesc *s = (Fl_Fontdesc*)((char*)fl_fonts + fnum * width);
+  s->mem_font_data = data;
+  s->mem_font_size = data_size;
+  s->mem_font_handle = NULL;  // No temp file handle needed
+
+  return fnum;
+}
+
+/**
+  Unload a font previously loaded with load_font().
+  \param font The font number returned by load_font().
+*/
+void Fl_Cairo_Graphics_Driver::unload_font(Fl_Font font) {
+  if (font < FL_FREE_FONT) return;
+
+  unsigned width = font_desc_size();
+  Fl_Fontdesc *s = (Fl_Fontdesc*)((char*)fl_fonts + font * width);
+
+  // Check if this is a memory font (has mem_font_data set)
+  if (s->mem_font_data) {
+    // Delete any cached font descriptors
+    for (Fl_Font_Descriptor* f = s->first; f;) {
+      Fl_Font_Descriptor* n = f->next;
+      delete f;
+      f = n;
+    }
+    s->first = NULL;
+
+    // Free the allocated name (allocated in load_font)
+    if (s->name) {
+      free((void*)s->name);
+    }
+
+    // Clear the font descriptor
+    s->name = NULL;
+    s->fontname[0] = 0;
+    s->mem_font_data = NULL;
+    s->mem_font_size = 0;
+    s->mem_font_handle = NULL;
+  }
+}
+
 #endif // USE_PANGO

src/drivers/GDI/Fl_GDI_Graphics_Driver.H

@@ -151,6 +151,8 @@ protected:
   const char* get_font_name(Fl_Font fnum, int* ap) FL_OVERRIDE;
   const char *font_name(int num) FL_OVERRIDE;
   void font_name(int num, const char *name) FL_OVERRIDE;
+  Fl_Font load_font(const void* data, size_t data_size, const char* font_name) FL_OVERRIDE;
+  void unload_font(Fl_Font font) FL_OVERRIDE;
   void global_gc() FL_OVERRIDE;
   void overlay_rect(int x, int y, int w , int h) FL_OVERRIDE;
   void cache_size(Fl_Image *img, int &width, int &height) FL_OVERRIDE;

src/drivers/GDI/Fl_GDI_Graphics_Driver_font.cxx

@@ -676,3 +676,99 @@ void Fl_GDI_Graphics_Driver::rtl_draw_unscaled(const char* c, int n, int x, int
   SetTextColor(gc_, oldColor);
 }
 #endif
+
+// Memory font loading for Windows using AddFontMemResourceEx
+
+/**
+  Load a TrueType or OpenType font from memory.
+  \param data Pointer to the font data in memory.
+  \param data_size Size of the font data in bytes.
+  \param font_name Name to register the font with, or NULL to use the embedded name.
+  \return Font number on success, or (Fl_Font)-1 on failure.
+*/
+Fl_Font Fl_GDI_Graphics_Driver::load_font(const void* data, size_t data_size, const char* font_name) {
+  if (!data || data_size == 0) return (Fl_Font)-1;
+
+  // Add font to Windows using AddFontMemResourceEx
+  DWORD num_fonts = 0;
+  HANDLE font_handle = AddFontMemResourceEx((PVOID)data, (DWORD)data_size, NULL, &num_fonts);
+  if (!font_handle || num_fonts == 0) {
+    return (Fl_Font)-1;
+  }
+
+  // Get the font name from the font data if not provided
+  const char* name_to_use = font_name;
+  char* allocated_name = NULL;
+
+  if (!name_to_use) {
+    // Try to extract the font family name from the TrueType font data
+    // The TrueType 'name' table (table ID 6) contains the font family name
+    // For simplicity, we require the caller to provide a name
+    // since parsing the name table is complex
+    RemoveFontMemResourceEx(font_handle);
+    return (Fl_Font)-1;
+  }
+
+  // Create a name with the required prefix for the platform (space = normal)
+  size_t name_len = strlen(name_to_use);
+  allocated_name = (char*)malloc(name_len + 2);
+  if (!allocated_name) {
+    RemoveFontMemResourceEx(font_handle);
+    return (Fl_Font)-1;
+  }
+  allocated_name[0] = ' ';  // Normal weight/style prefix
+  memcpy(allocated_name + 1, name_to_use, name_len + 1);
+
+  // Find a free font slot
+  Fl_Font fnum = Fl::set_fonts(NULL);
+  if (fnum == 0) fnum = FL_FREE_FONT;
+
+  // Register the font
+  Fl::set_font(fnum, allocated_name);
+
+  // Store the memory font information
+  unsigned width = font_desc_size();
+  Fl_Fontdesc *s = (Fl_Fontdesc*)((char*)fl_fonts + fnum * width);
+  s->mem_font_data = data;
+  s->mem_font_size = data_size;
+  s->mem_font_handle = font_handle;
+
+  return fnum;
+}
+
+/**
+  Unload a font previously loaded with load_font().
+  \param font The font number returned by load_font().
+*/
+void Fl_GDI_Graphics_Driver::unload_font(Fl_Font font) {
+  if (font < FL_FREE_FONT) return;
+
+  unsigned width = font_desc_size();
+  Fl_Fontdesc *s = (Fl_Fontdesc*)((char*)fl_fonts + font * width);
+
+  // Check if this is a memory font
+  if (s->mem_font_handle) {
+    // Delete any cached font descriptors
+    for (Fl_Font_Descriptor* f = s->first; f;) {
+      Fl_Font_Descriptor* n = f->next;
+      delete f;
+      f = n;
+    }
+    s->first = NULL;
+
+    // Remove the font from Windows
+    RemoveFontMemResourceEx((HANDLE)s->mem_font_handle);
+
+    // Free the allocated name (allocated in load_font)
+    if (s->name) {
+      free((void*)s->name);
+    }
+
+    // Clear the font descriptor
+    s->name = NULL;
+    s->fontname[0] = 0;
+    s->mem_font_data = NULL;
+    s->mem_font_size = 0;
+    s->mem_font_handle = NULL;
+  }
+}

src/drivers/Quartz/Fl_Quartz_Graphics_Driver.H

@@ -132,6 +132,8 @@ protected:
   Fl_Font set_fonts(const char* xstarname) FL_OVERRIDE;
   void set_fontname_in_fontdesc(Fl_Fontdesc *f);
   void uncache_pixmap(fl_uintptr_t p) FL_OVERRIDE;
+  Fl_Font load_font(const void* data, size_t data_size, const char* font_name) FL_OVERRIDE;
+  void unload_font(Fl_Font font) FL_OVERRIDE;
 
   void descriptor_init(const char* name, Fl_Fontsize Size, Fl_Quartz_Font_Descriptor *d);
   void overlay_rect(int x, int y, int w , int h) FL_OVERRIDE;