A Million Little Pieces Of My Mind

NamtiraLib

SuperFonts

By: Paul S Cilwa Posted: 4/10/2026 Page Views: 26
Hashtags: #Namtira #VisualBasic #VBNET #ClassLibrary #NamtiraLib #SuperFonts #Font #TrueType #OpenType
Classes for loading, inspecting, and previewing TrueType and OpenType font files.
Estimated reading time: 3 minute(s) (682 words)

.NET can render any installed font, but it offers no convenient way to load a font file from disk, discover which styles it supports, or build a preview. SuperFonts provides two classes that fill this gap: FontFileInfo wraps a single font file and exposes its families and available styles, while FontFileList scans a folder (or the system Fonts directory) and collects the results.

Class FontFileInfo
MemberParametersExample
NewInfo As FileInfoDim ffi As New FontFileInfo(myFile)
NewPath As StringDim ffi As New FontFileInfo("C:\Fonts\Lato.ttf")
DisplayName—ffi.DisplayName → "Lato (Regular, Bold, Italic)"
IsSystemFont—ffi.IsSystemFont
AvailableStyles—ffi.AvailableStyles → IReadOnlyList(Of FontStyle)
FontStyle—ffi.FontStyle (default Regular)
Families—ffi.Families → IReadOnlyList(Of FontFamily)
FontFamily—ffi.FontFamily → primary family
Tag—ffi.Tag = "custom"
FileInfo—ffi.FileInfo → underlying FileInfo
FullName—ffi.FullName → full file path
Extension—ffi.Extension → ".ttf"
GetPreviewFontSize As Single, Style As FontStyleffi.GetPreviewFont(14, FontStyle.Bold)
Class FontFileList (Inherits List(Of FontFileInfo))
NewFolderPath As StringDim ffl As New FontFileList("C:\MyFonts")
NewPreloadSystemFonts As Boolean (opt)Dim ffl As New FontFileList(True)
LoadFromSystem—ffl.LoadFromSystem()

FontFileInfo

Each FontFileInfo wraps a single font file. The constructor loads it via a PrivateFontCollection, detects which styles (Regular, Bold, Italic, etc.) the font supports, and builds a human-readable DisplayName.

Imports System.Drawing.Text Imports System.IO Public Class FontFileInfo Public ReadOnly DisplayName As String Public ReadOnly IsSystemFont As Boolean Public ReadOnly AvailableStyles As IReadOnlyList(Of FontStyle) Public FontStyle As FontStyle = FontStyle.Regular Public ReadOnly Families As IReadOnlyList(Of FontFamily) Public ReadOnly FontFamily As FontFamily Public Tag As String = String.Empty Private ReadOnly MyInfo As FileInfo Private ReadOnly MyFonts As New PrivateFontCollection Public Sub New(Info As FileInfo) MyInfo = Info MyFonts.AddFontFile(MyInfo.FullName) If MyFonts.Families.Length = 0 Then Throw New Exception("No font families found in file: " & MyInfo.FullName) End If FontFamily = MyFonts.Families(0) AvailableStyles = DetectStyles(FontFamily) DisplayName = BuildDisplayName(FontFamily) End Sub Public Sub New(Path As String) Me.New(New FileInfo(Path)) End Sub End Class

The private BuildDisplayName helper joins the family name with a parenthesized list of available styles. DetectStyles iterates every FontStyle enum value and keeps only those the family reports as available.

Private Function BuildDisplayName(Family As FontFamily) As String Dim styleNames = AvailableStyles.Select(Function(s) s.ToString()) Return Family.Name & " (" & String.Join(", ", styleNames) & ")" End Function Private Function DetectStyles(Family As FontFamily) As List(Of FontStyle) Dim Styles As New List(Of FontStyle) For Each s As FontStyle In [Enum].GetValues(GetType(FontStyle)) If Family.IsStyleAvailable(s) Then Styles.Add(s) End If Next Return Styles End Function

Several read-only properties expose the underlying FileInfo, its full path, and extension, keeping the caller from needing to dig into the wrapped object.

Public ReadOnly Property FileInfo As FileInfo Get Return MyInfo End Get End Property Public ReadOnly Property FullName As String Get Return MyInfo.FullName End Get End Property Public ReadOnly Property Extension As String Get Return MyInfo.Extension End Get End Property

GetPreviewFont creates a Font instance from the loaded family at a given size and style—handy for rendering sample text in a UI.

Public Function GetPreviewFont(Size As Single, Style As FontStyle) As Font Return New Font(Me.FontFamily, Size, Style) End Function

FontFileList

FontFileList inherits from List(Of FontFileInfo) and adds the ability to scan a folder for font files (TrueType, OpenType, and TrueType/OpenType Collections). The folder-path constructor loads immediately; the parameterless constructor optionally preloads the Windows system fonts.

Public Class FontFileList Inherits List(Of FontFileInfo) Private Shared ReadOnly FontFileExtensions As String() = {".ttf", ".otf", ".ttc", ".otc"} Public Sub New(FolderPath As String) MyBase.New LoadFromFolder(FolderPath) End Sub Public Sub New(Optional PreloadSystemFonts As Boolean = False) MyBase.New If PreloadSystemFonts Then LoadFromSystem() End Sub Private Sub LoadFromFolder(FolderPath As String) If Directory.Exists(FolderPath) Then For Each F In Directory.GetFiles(FolderPath) If FontFileExtensions.Contains(Path.GetExtension(F).ToLower()) Then Try Add(New FontFileInfo(F)) Catch ex As Exception ' Ignore invalid or unreadable font files End Try End If Next End If End Sub Public Sub LoadFromSystem() LoadFromFolder(Path.Combine( Environment.GetFolderPath(Environment.SpecialFolder.Windows), "Fonts")) End Sub End Class

The Invention of Fonts

By: Paul S Cilwa Posted: 1/7/2026 Page Views: 20
Hashtags: #Namtira #VisualBasic #VBNET #ClassLibrary #NamtiraLib #Fonts #Typography #MovableType #BiSheng #Blackletter #RenaissanceType #Italics #BoldType #Underlining #Serif #SansSerif #TypeDesign #PrintingHistory
A historical exploration of how fonts evolved from handwritten scripts to movable type and modern digital typography, tracing calligraphic origins, East Asian printing innovations, Renaissance italics, and the development of bold and underline as tools of emphasis.
Estimated reading time: 4 minute(s) (941 words)

Printing began as a craft of translation: printers reproduced the familiar shapes readers already knew from manuscripts, so the first printed books deliberately echoed scribal hands. In Europe this is most visible in the mid?15th century, where the dense blackletter of early presses was chosen to match the look of medieval bookhands and reassure buyers that printed books were legitimate continuations of manuscript culture. That impulse—to make reproducible pieces that look like handwriting—set the basic relationship between calligraphy and type: letterforms were not invented in a vacuum but were abstracted, regularized, and simplified to survive the mechanical processes of casting, setting, inking, and pressing.

How Fonts Moved From Print To Printout

By: Paul S Cilwa Posted: 1/7/2026 Page Views: 25
Hashtags: #Fonts #Typography #MetalType #Phototypesetting #PostScript #TrueType #OpenType #VariableFonts #BzierCurves #Rasterization #Hinting #Antialiasing #DesktopPublishing
How fonts evolved from physical metal type to digital typography, tracing the shift from hand-set sorts to phototypesetting, PostScript, TrueType, OpenType, and modern variable fonts, including how digital letterforms are rendered, hinted, and rasterized on screens.
Estimated reading time: 3 minute(s) (499 words)

The word font originally referred to a concrete inventory: a complete set of sorts for one size and style used by a compositor. That practical, material meaning shaped how printers talked about type for centuries—a font was what you bought, stored, and set into a chase. As printing moved from hand?set metal to mechanical and phototypesetting, the idea of a font broadened to include families of related cuts and the notion of interchangeable styles. When computers entered the picture, the term migrated again: a font became a digital file or resource that a program could load, select, and render. This semantic drift reflects a deeper technical shift from physical objects to encoded descriptions of shapes and behaviors.