From 2085979780cb25213301476629fd568069afe4ee Mon Sep 17 00:00:00 2001
From: ebenali <54529923+ebenali@users.noreply.github.com>
Date: Sun, 21 Jun 2026 17:36:30 +0000
Subject: [PATCH] feat: per-place fonts + a live theme preview in wbconf

Add Openbox-style font configuration and make wbconf fancier with a live
theme/fonts preview.

Compositor:
- Theme gains FontSpec fields per place (active/inactive title, menu header,
  menu item, OSD); FontSpec.family is now std::string (safe to own parsed
  names). The frame/menu/switcher style adapters set each resolved
  TextStyle.font from them, so a configured title font also drives the titlebar
  height (frame_metrics measures the label font).
- config.cpp parses Openbox <theme><font place="..."><name>/<size>/<weight>,
  applied onto the loaded theme. New pure wb::font_place_from_name() maps the
  Openbox place names (incl. OSD aliases) to FontPlace; unit-tested.

wbconf:
- New Fonts tab with a GtkFontDialogButton per place; RcDocument reads/writes
  the structured <font> elements as Pango "Family [Bold] Size" strings
  (round-trip unit-tested, including create/update/remove).
- New live Preview pane on the Theme tab: a GtkDrawingArea that renders sample
  active/inactive titlebars (with window buttons) and a menu using the SAME
  theme/style/render pipeline as the compositor, so it is pixel-faithful. It
  reflects the live, unsaved selection and redraws when the theme or any font
  changes. wbconf now links style/widget/render in addition to theme.
- data/rc.xml documents the <font> block.

Tests: font_place_from_name + theme-font-flow + wbconf font round-trip; full
suite 27 green (g++/ASan), clang + release clean. Headless: a 20pt title font
enlarges the titlebar; wbconf maps with the Fonts tab and the preview renders
with no Cairo/Pango/GTK errors.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 data/rc.xml               |   9 +-
 include/waybox/theme.hpp  |  25 ++++-
 include/waybox/wbconf.hpp |   8 ++
 test/style_test.cpp       |  19 ++++
 test/theme_test.cpp       |  17 +++
 test/wbconf_test.cpp      |  28 +++++
 waybox/config.cpp         |  63 +++++++++++
 waybox/render.cpp         |   2 +-
 waybox/style.cpp          |   4 +
 waybox/theme.cpp          |  21 ++++
 waybox/wbconf.cpp         | 129 ++++++++++++++++++++++
 wbconf/main.cpp           | 219 +++++++++++++++++++++++++++++++++++++-
 wbconf/meson.build        |   5 +-
 13 files changed, 543 insertions(+), 6 deletions(-)

diff --git a/data/rc.xml b/data/rc.xml
index fa0fecd..7fa4574 100644
--- a/data/rc.xml
+++ b/data/rc.xml
@@ -11,9 +11,16 @@
   <!-- Theme for compositor-drawn chrome (the root menu, and titlebars once
        server-side decorations land). <name> resolves an Openbox theme under
        <datadir>/themes/<name>/openbox-3/themerc (e.g. Clearlooks). Omit (as
-       below) to use the built-in default; uncomment and set a name to theme it. -->
+       below) to use the built-in default; uncomment and set a name to theme it.
+       Per-place fonts live here too (Openbox <font place="..."> convention):
+       places are ActiveWindow, InactiveWindow, MenuHeader, MenuItem and
+       ActiveOnScreenDisplay. The titlebar height tracks the title font size. -->
   <!-- <theme>
     <name>Clearlooks</name>
+    <font place="ActiveWindow"><name>Sans</name><size>10</size><weight>bold</weight></font>
+    <font place="InactiveWindow"><name>Sans</name><size>10</size><weight>normal</weight></font>
+    <font place="MenuItem"><name>Sans</name><size>10</size><weight>normal</weight></font>
+    <font place="ActiveOnScreenDisplay"><name>Sans</name><size>10</size><weight>bold</weight></font>
   </theme> -->
   <!-- waybox-only extensions (Openbox ignores this block). Menu behaviour:
        submenuOpen="hover|click", hoverDelay (ms before a submenu opens on
diff --git a/include/waybox/theme.hpp b/include/waybox/theme.hpp
index 8bf31f1..b72696f 100644
--- a/include/waybox/theme.hpp
+++ b/include/waybox/theme.hpp
@@ -47,7 +47,7 @@ struct Texture {
 /* A font, by Pango family/size. Lives here (not render.hpp) so the pure theme
  * and style layers can reference it without pulling in Cairo. */
 struct FontSpec {
-	const char *family = "sans";
+	std::string family = "sans";
 	int size_pt = 10;
 	bool bold = false;
 };
@@ -116,6 +116,15 @@ struct Theme {
 	WindowColors window_active;
 	WindowColors window_inactive;
 	MenuColors menu;
+
+	/* Per-place fonts (rc.xml <theme><font place="...">). Openbox keeps fonts
+	 * in rc.xml rather than themerc; config.cpp fills these in. All default to
+	 * the FontSpec default (sans 10pt). */
+	FontSpec font_active_title;     /* place="ActiveWindow" */
+	FontSpec font_inactive_title;   /* place="InactiveWindow" */
+	FontSpec font_menu_header;      /* place="MenuHeader" */
+	FontSpec font_menu_item;        /* place="MenuItem" */
+	FontSpec font_osd;              /* place="ActiveOnScreenDisplay" */
 };
 
 /*
@@ -128,6 +137,20 @@ std::optional<Color> parse_color(std::string_view spec);
 /* Parse a themerc justify value ("left"/"center"/"centre"/"right"). */
 std::optional<Justify> justify_from_name(std::string_view name);
 
+/* The configurable text "places" for fonts (rc.xml <theme><font place="...">),
+ * mapping Openbox's place names to the Theme's font fields. */
+enum class FontPlace {
+	ActiveWindow,
+	InactiveWindow,
+	MenuHeader,
+	MenuItem,
+	OnScreenDisplay,
+};
+
+/* Map an Openbox font place name to a FontPlace (case-insensitive). Recognises
+ * the Openbox names plus the OSD aliases; returns nullopt if unknown. */
+std::optional<FontPlace> font_place_from_name(std::string_view name);
+
 /* A Theme with the built-in defaults (a neutral fallback). */
 Theme default_theme();
 
diff --git a/include/waybox/wbconf.hpp b/include/waybox/wbconf.hpp
index 7def0fd..0562dca 100644
--- a/include/waybox/wbconf.hpp
+++ b/include/waybox/wbconf.hpp
@@ -43,6 +43,14 @@ struct WayboxSettings {
 	std::optional<std::string> switcher_order;      /* mru | stacking | spatial */
 	std::optional<bool> switcher_osd;
 	std::optional<bool> switcher_wrap;
+
+	/* Per-place fonts (theme/font place="..."). Each is "Family Size" in the
+	 * Pango convention (e.g. "Sans Bold 11"); std::nullopt means unset. */
+	std::optional<std::string> font_active_window;   /* place="ActiveWindow" */
+	std::optional<std::string> font_inactive_window; /* place="InactiveWindow" */
+	std::optional<std::string> font_menu_header;     /* place="MenuHeader" */
+	std::optional<std::string> font_menu_item;       /* place="MenuItem" */
+	std::optional<std::string> font_osd;             /* place="OnScreenDisplay" */
 };
 
 /*
diff --git a/test/style_test.cpp b/test/style_test.cpp
index 927c422..15c6335 100644
--- a/test/style_test.cpp
+++ b/test/style_test.cpp
@@ -104,3 +104,22 @@ WB_TEST(enum_parsers_round_trip_names) {
 	WB_CHECK(wb::justify_from_name("right") == Justify::Right);
 	WB_CHECK(!wb::justify_from_name("bogus").has_value());
 }
+
+WB_TEST(theme_fonts_flow_into_resolved_styles) {
+	wb::Theme t = wb::default_theme();
+	t.font_active_title = {"Inter", 13, true};
+	t.font_inactive_title = {"Inter", 11, false};
+	t.font_menu_item = {"Cantarell", 12, false};
+	t.font_osd = {"Mono", 9, false};
+
+	wb::FrameStyle fa = wb::frame_style_from_theme(t, true);
+	WB_CHECK(fa.label.font.family == "Inter");
+	WB_CHECK(fa.label.font.size_pt == 13 && fa.label.font.bold == true);
+	wb::FrameStyle fi = wb::frame_style_from_theme(t, false);
+	WB_CHECK(fi.label.font.size_pt == 11 && fi.label.font.bold == false);
+
+	wb::MenuStyle ms = wb::menu_style_from_theme(t);
+	WB_CHECK(ms.item_text.font.family == "Cantarell");
+	wb::SwitcherStyle ss = wb::switcher_style_from_theme(t);
+	WB_CHECK(ss.item_text.font.family == "Mono" && ss.item_text.font.size_pt == 9);
+}
diff --git a/test/theme_test.cpp b/test/theme_test.cpp
index f4657c6..357b74c 100644
--- a/test/theme_test.cpp
+++ b/test/theme_test.cpp
@@ -160,3 +160,20 @@ WB_TEST(search_paths_default_data_dirs_and_no_xdg_home) {
 	WB_CHECK(paths[0] == "/home/u/.local/share/themes/Onyx/openbox-3/themerc");
 	WB_CHECK(paths[3] == "/usr/share/themes/Onyx/openbox-3/themerc");
 }
+
+WB_TEST(font_place_names_map_to_places) {
+	using wb::FontPlace;
+	WB_CHECK(wb::font_place_from_name("ActiveWindow") == FontPlace::ActiveWindow);
+	WB_CHECK(wb::font_place_from_name("InactiveWindow") == FontPlace::InactiveWindow);
+	WB_CHECK(wb::font_place_from_name("MenuHeader") == FontPlace::MenuHeader);
+	WB_CHECK(wb::font_place_from_name("MenuItem") == FontPlace::MenuItem);
+	/* case-insensitive + OSD aliases collapse to one place */
+	WB_CHECK(wb::font_place_from_name("activewindow") == FontPlace::ActiveWindow);
+	WB_CHECK(wb::font_place_from_name("ActiveOnScreenDisplay") ==
+			FontPlace::OnScreenDisplay);
+	WB_CHECK(wb::font_place_from_name("InactiveOnScreenDisplay") ==
+			FontPlace::OnScreenDisplay);
+	WB_CHECK(wb::font_place_from_name("OnScreenDisplay") ==
+			FontPlace::OnScreenDisplay);
+	WB_CHECK(!wb::font_place_from_name("Nonsense").has_value());
+}
diff --git a/test/wbconf_test.cpp b/test/wbconf_test.cpp
index 4fdde17..51f820a 100644
--- a/test/wbconf_test.cpp
+++ b/test/wbconf_test.cpp
@@ -113,3 +113,31 @@ WB_TEST(clearing_removes_nodes_and_attrs) {
 	WB_CHECK(xml.find("icons=") == std::string::npos);
 	WB_CHECK(xml.find("<name>") == std::string::npos);
 }
+
+WB_TEST(round_trips_fonts) {
+	auto doc = RcDocument::from_string(kMinimalRc);
+	WB_CHECK(doc.has_value());
+	WayboxSettings s = doc->read();
+	s.font_active_window = "Inter Bold 12";
+	s.font_menu_item = "Cantarell 11";
+	doc->apply(s);
+
+	std::string xml = doc->to_string();
+	/* Structured font element written under <theme>. */
+	WB_CHECK(xml.find("place=\"ActiveWindow\"") != std::string::npos);
+	WB_CHECK(xml.find("<name>Inter</name>") != std::string::npos);
+	WB_CHECK(xml.find("<size>12</size>") != std::string::npos);
+	WB_CHECK(xml.find("<weight>bold</weight>") != std::string::npos);
+
+	auto doc2 = RcDocument::from_string(xml);
+	WB_CHECK(doc2.has_value());
+	WayboxSettings r = doc2->read();
+	WB_CHECK(r.font_active_window && *r.font_active_window == "Inter Bold 12");
+	WB_CHECK(r.font_menu_item && *r.font_menu_item == "Cantarell 11");
+	WB_CHECK(!r.font_osd.has_value());
+
+	/* Clearing removes the font element. */
+	r.font_active_window = std::nullopt;
+	doc2->apply(r);
+	WB_CHECK(doc2->to_string().find("place=\"ActiveWindow\"") == std::string::npos);
+}
diff --git a/waybox/config.cpp b/waybox/config.cpp
index 8811a45..9a941e6 100644
--- a/waybox/config.cpp
+++ b/waybox/config.cpp
@@ -454,6 +454,65 @@ static void parse_titlebar(struct wb_config *config, xmlXPathContextPtr ctxt) {
 	xmlXPathFreeObject(object);
 }
 
+/* Parse Openbox font configuration: <theme><font place="...">[<name>, <size>,
+ * <weight>bold</weight>]</font></theme>. Each place maps to a Theme font field;
+ * fonts live in rc.xml (not themerc), so this runs after the theme is loaded. */
+static void parse_fonts(struct wb_config *config, xmlXPathContextPtr ctxt) {
+	xmlXPathObjectPtr object = xmlXPathEvalExpression(
+			(const xmlChar *) "//ob:theme/ob:font", ctxt);
+	if (object == NULL)
+		return;
+	if (object->nodesetval) {
+		for (int i = 0; i < object->nodesetval->nodeNr; i++) {
+			xmlNode *node = object->nodesetval->nodeTab[i];
+			if (node == NULL)
+				continue;
+			const char *place = (const char *) get_attribute(node, "place");
+			if (place == NULL)
+				continue;
+			auto fp = wb::font_place_from_name(place);
+			if (!fp)
+				continue;
+			wb::FontSpec *target = nullptr;
+			switch (*fp) {
+			case wb::FontPlace::ActiveWindow:
+				target = &config->theme.font_active_title; break;
+			case wb::FontPlace::InactiveWindow:
+				target = &config->theme.font_inactive_title; break;
+			case wb::FontPlace::MenuHeader:
+				target = &config->theme.font_menu_header; break;
+			case wb::FontPlace::MenuItem:
+				target = &config->theme.font_menu_item; break;
+			case wb::FontPlace::OnScreenDisplay:
+				target = &config->theme.font_osd; break;
+			}
+			if (target == nullptr)
+				continue;
+			for (xmlNode *c = node->children; c != NULL; c = c->next) {
+				if (c->type != XML_ELEMENT_NODE)
+					continue;
+				xmlChar *content = xmlNodeGetContent(c);
+				const char *v = content ? (const char *) content : "";
+				if (xmlStrcmp(c->name, (const xmlChar *) "name") == 0 &&
+						v[0] != '\0') {
+					target->family = v;
+				} else if (xmlStrcmp(c->name, (const xmlChar *) "size") == 0 &&
+						v[0] != '\0') {
+					int s = atoi(v);
+					if (s > 0)
+						target->size_pt = s;
+				} else if (xmlStrcmp(c->name, (const xmlChar *) "weight") == 0) {
+					target->bold = (xmlStrcasecmp((const xmlChar *) v,
+							(const xmlChar *) "bold") == 0);
+				}
+				if (content)
+					xmlFree(content);
+			}
+		}
+	}
+	xmlXPathFreeObject(object);
+}
+
 bool init_config(struct wb_server *server) {
 	struct wb_config *config = new (std::nothrow) wb_config{};
 	if (config == NULL)
@@ -554,6 +613,10 @@ bool init_config(struct wb_server *server) {
 		config->theme = wb::default_theme();
 	}
 
+	/* Per-place fonts: <theme><font place="...">. Applied onto the loaded
+	 * theme so they override its defaults. */
+	parse_fonts(config, ctxt);
+
 	/* Menu behaviour: waybox extension block <waybox><menu .../></waybox>, which
 	 * Openbox ignores. Attributes: submenuOpen="hover|click", hoverDelay="ms",
 	 * wrap="yes|no". */
diff --git a/waybox/render.cpp b/waybox/render.cpp
index 187ed30..abf824a 100644
--- a/waybox/render.cpp
+++ b/waybox/render.cpp
@@ -21,7 +21,7 @@ PangoLayout *make_layout(cairo_t *cr, std::string_view text,
 		const FontSpec &font) {
 	PangoLayout *layout = pango_cairo_create_layout(cr);
 	PangoFontDescription *desc = pango_font_description_new();
-	pango_font_description_set_family(desc, font.family);
+	pango_font_description_set_family(desc, font.family.c_str());
 	pango_font_description_set_weight(desc,
 			font.bold ? PANGO_WEIGHT_BOLD : PANGO_WEIGHT_NORMAL);
 	pango_font_description_set_size(desc, font.size_pt * PANGO_SCALE);
diff --git a/waybox/style.cpp b/waybox/style.cpp
index 67277c9..76e23f9 100644
--- a/waybox/style.cpp
+++ b/waybox/style.cpp
@@ -35,12 +35,14 @@ MenuStyle menu_style_from_theme(const Theme &theme) {
 
 	s.title_bar.fill = paint_from_texture(m.title_bg);
 	s.title_text.color = m.title_text;
+	s.title_text.font = theme.font_menu_header;
 
 	s.item.normal = StateStyle{paint_from_texture(m.items_bg), m.items_text};
 	s.item.hover = StateStyle{paint_from_texture(m.items_active_bg), m.items_active_text};
 	s.item.pressed = s.item.hover;
 	s.item.disabled = StateStyle{paint_from_texture(m.items_bg), m.separator};
 	s.item_text.color = m.items_text;
+	s.item_text.font = theme.font_menu_item;
 
 	s.separator = m.separator;
 	s.item_spacing = theme.menu_item_spacing;
@@ -62,6 +64,7 @@ FrameStyle frame_style_from_theme(const Theme &theme, bool active) {
 			theme.padding_y, theme.padding_x};
 	f.label.color = w.label_text;
 	f.label.justify = theme.label_justify;
+	f.label.font = active ? theme.font_active_title : theme.font_inactive_title;
 
 	f.handle.fill = paint_from_texture(w.handle_bg);
 	f.grip.fill = paint_from_texture(w.grip_bg);
@@ -129,6 +132,7 @@ SwitcherStyle switcher_style_from_theme(const Theme &theme) {
 	s.item.pressed = s.item.hover;
 	s.item.disabled = StateStyle{paint_from_texture(m.items_bg), m.separator};
 	s.item_text.color = m.items_text;
+	s.item_text.font = theme.font_osd;
 	return s;
 }
 
diff --git a/waybox/theme.cpp b/waybox/theme.cpp
index 0ebd963..5d7b358 100644
--- a/waybox/theme.cpp
+++ b/waybox/theme.cpp
@@ -175,6 +175,27 @@ std::optional<Justify> justify_from_name(std::string_view name) {
 	return std::nullopt;
 }
 
+std::optional<FontPlace> font_place_from_name(std::string_view name) {
+	std::string n;
+	n.reserve(name.size());
+	for (char c : name)
+		n.push_back(static_cast<char>(std::tolower(
+				static_cast<unsigned char>(c))));
+	if (n == "activewindow")
+		return FontPlace::ActiveWindow;
+	if (n == "inactivewindow")
+		return FontPlace::InactiveWindow;
+	if (n == "menuheader")
+		return FontPlace::MenuHeader;
+	if (n == "menuitem")
+		return FontPlace::MenuItem;
+	/* Openbox distinguishes active/inactive OSD; waybox uses one OSD font. */
+	if (n == "activeonscreendisplay" || n == "inactiveonscreendisplay" ||
+			n == "onscreendisplay")
+		return FontPlace::OnScreenDisplay;
+	return std::nullopt;
+}
+
 namespace {
 
 void apply_color(std::string_view value, Color &out) {
diff --git a/waybox/wbconf.cpp b/waybox/wbconf.cpp
index 653e151..98f6f5b 100644
--- a/waybox/wbconf.cpp
+++ b/waybox/wbconf.cpp
@@ -131,6 +131,86 @@ std::optional<bool> to_bool(const std::optional<std::string> &s) {
 
 const char *bool_str(bool b) { return b ? "yes" : "no"; }
 
+/* The <theme><font place="P"> element, or nullptr. */
+xmlNode *find_font(xmlNode *root, const char *place) {
+	xmlNode *theme = child_named(root, "theme");
+	if (theme == nullptr)
+		return nullptr;
+	for (xmlNode *c = theme->children; c != nullptr; c = c->next) {
+		if (!is_element(c, "font"))
+			continue;
+		if (auto p = attr_value(c, "place"); p && *p == place)
+			return c;
+	}
+	return nullptr;
+}
+
+/* Compose a <font place="P"> into a Pango-style "Family [Bold] Size" string,
+ * or nullopt if the place is absent. */
+std::optional<std::string> read_font(xmlNode *root, const char *place) {
+	xmlNode *font = find_font(root, place);
+	if (font == nullptr)
+		return std::nullopt;
+	std::string family = node_text(child_named(font, "name")).value_or("Sans");
+	std::optional<std::string> size = node_text(child_named(font, "size"));
+	std::optional<std::string> weight = node_text(child_named(font, "weight"));
+	std::string out = family;
+	if (weight) {
+		std::string w = *weight;
+		std::transform(w.begin(), w.end(), w.begin(),
+				[](unsigned char c) { return std::tolower(c); });
+		if (w == "bold")
+			out += " Bold";
+	}
+	if (size && !size->empty())
+		out += " " + *size;
+	return out;
+}
+
+/* Split a Pango-style "Family [Bold] Size" string into (family, size, bold).
+ * A trailing integer is the size; a "Bold" token sets weight; the rest is the
+ * family. */
+void parse_font(const std::string &spec, std::string &family, std::string &size,
+		bool &bold) {
+	std::vector<std::string> tokens;
+	std::string cur;
+	for (char c : spec) {
+		if (c == ' ') {
+			if (!cur.empty()) { tokens.push_back(cur); cur.clear(); }
+		} else {
+			cur.push_back(c);
+		}
+	}
+	if (!cur.empty())
+		tokens.push_back(cur);
+
+	bold = false;
+	size.clear();
+	std::vector<std::string> fam;
+	for (const std::string &t : tokens) {
+		std::string lo = t;
+		std::transform(lo.begin(), lo.end(), lo.begin(),
+				[](unsigned char c) { return std::tolower(c); });
+		bool numeric = !t.empty() &&
+				t.find_first_not_of("0123456789") == std::string::npos;
+		if (numeric) {
+			size = t;  /* last numeric token wins */
+		} else if (lo == "bold") {
+			bold = true;
+		} else if (lo == "regular" || lo == "normal" || lo == "italic" ||
+				lo == "oblique" || lo == "light" || lo == "medium") {
+			/* style/weight words we don't model: drop from the family name */
+		} else {
+			fam.push_back(t);
+		}
+	}
+	family.clear();
+	for (size_t i = 0; i < fam.size(); ++i)
+		family += (i ? " " : "") + fam[i];
+	if (family.empty())
+		family = "Sans";
+}
+
 }  // namespace
 
 RcDocument::RcDocument(RcDocument &&o) noexcept : doc_(o.doc_) {
@@ -202,6 +282,12 @@ WayboxSettings RcDocument::read() const {
 	s.titlebar_pad_y = to_int(attr_value(tb, "paddingY"));
 	s.titlebar_button_size = to_int(attr_value(tb, "buttonSize"));
 	s.titlebar_resize_grab = to_int(attr_value(tb, "resizeGrab"));
+
+	s.font_active_window = read_font(root, "ActiveWindow");
+	s.font_inactive_window = read_font(root, "InactiveWindow");
+	s.font_menu_header = read_font(root, "MenuHeader");
+	s.font_menu_item = read_font(root, "MenuItem");
+	s.font_osd = read_font(root, "ActiveOnScreenDisplay");
 	return s;
 }
 
@@ -244,6 +330,43 @@ std::optional<std::string> bool_opt_str(const std::optional<bool> &v) {
 	return std::string(bool_str(*v));
 }
 
+/* Create/update or remove the <theme><font place="P"> element from a
+ * Pango-style "Family [Bold] Size" string. */
+void put_font(xmlNode *root, const char *place,
+		const std::optional<std::string> &value) {
+	xmlNode *existing = find_font(root, place);
+	if (!value) {
+		if (existing) {
+			xmlUnlinkNode(existing);
+			xmlFreeNode(existing);
+		}
+		return;
+	}
+	std::string family, size;
+	bool bold = false;
+	parse_font(*value, family, size, bold);
+
+	xmlNode *theme = ensure_child(root, "theme");
+	xmlNode *font = existing;
+	if (font == nullptr) {
+		font = xmlNewNode(theme->ns, xc("font"));
+		xmlAddChild(theme, font);
+	}
+	xmlSetProp(font, xc("place"), xc(place));
+	auto set_child = [&](const char *name, const std::string &text) {
+		xmlNode *c = child_named(font, name);
+		if (c == nullptr) {
+			c = xmlNewNode(theme->ns, xc(name));
+			xmlAddChild(font, c);
+		}
+		xmlNodeSetContent(c, xc(text.c_str()));
+	};
+	set_child("name", family);
+	if (!size.empty())
+		set_child("size", size);
+	set_child("weight", bold ? "bold" : "normal");
+}
+
 }  // namespace
 
 void RcDocument::apply(const WayboxSettings &s) {
@@ -273,6 +396,12 @@ void RcDocument::apply(const WayboxSettings &s) {
 			int_str(s.titlebar_button_size));
 	put_attr(root, {"waybox", "titlebar"}, "resizeGrab",
 			int_str(s.titlebar_resize_grab));
+
+	put_font(root, "ActiveWindow", s.font_active_window);
+	put_font(root, "InactiveWindow", s.font_inactive_window);
+	put_font(root, "MenuHeader", s.font_menu_header);
+	put_font(root, "MenuItem", s.font_menu_item);
+	put_font(root, "ActiveOnScreenDisplay", s.font_osd);
 }
 
 std::string RcDocument::to_string() const {
diff --git a/wbconf/main.cpp b/wbconf/main.cpp
index f3f4dc7..e201500 100644
--- a/wbconf/main.cpp
+++ b/wbconf/main.cpp
@@ -28,6 +28,9 @@
 #include <unistd.h>
 
 #include "waybox/wbconf.hpp"
+#include "waybox/theme.hpp"
+#include "waybox/style.hpp"
+#include "waybox/render.hpp"
 
 #ifndef GETTEXT_PACKAGE
 #define GETTEXT_PACKAGE "waybox"
@@ -147,6 +150,16 @@ struct Ui {
 	GtkDropDown *switcher_order = nullptr;  /* mru / stacking / spatial */
 	GtkSwitch *switcher_osd = nullptr;
 	GtkSwitch *switcher_wrap = nullptr;
+
+	/* Fonts (GtkFontDialogButton per place) */
+	GtkFontDialogButton *font_active = nullptr;
+	GtkFontDialogButton *font_inactive = nullptr;
+	GtkFontDialogButton *font_menu_header = nullptr;
+	GtkFontDialogButton *font_menu_item = nullptr;
+	GtkFontDialogButton *font_osd = nullptr;
+
+	/* Live theme preview (redrawn when the theme/fonts change). */
+	GtkWidget *preview = nullptr;
 };
 
 const char *const kPlacement[] = {"Smart", "Center", "UnderMouse", nullptr};
@@ -235,7 +248,167 @@ GtkDropDown *add_dropdown(GtkWidget *grid, int row, const char *label,
 	return GTK_DROP_DOWN(dd);
 }
 
-/* ---- Read settings into the widgets ---------------------------------- */
+/* ---- Fonts + live theme preview -------------------------------------- */
+
+GtkFontDialogButton *add_font(GtkWidget *grid, int row, const char *label) {
+	grid_label(grid, row, label);
+	GtkFontDialog *dialog = gtk_font_dialog_new();
+	GtkWidget *btn = gtk_font_dialog_button_new(dialog);
+	gtk_widget_set_hexpand(btn, TRUE);
+	gtk_grid_attach(GTK_GRID(grid), btn, 1, row, 1, 1);
+	return GTK_FONT_DIALOG_BUTTON(btn);
+}
+
+/* Read a font button as a Pango-style "Family [Bold] Size" string, or nullopt
+ * if it was never set. */
+std::optional<std::string> font_value(GtkFontDialogButton *b) {
+	PangoFontDescription *d = gtk_font_dialog_button_get_font_desc(b);
+	if (d == nullptr)
+		return std::nullopt;
+	char *s = pango_font_description_to_string(d);
+	std::string out = s ? s : "";
+	g_free(s);
+	if (out.empty())
+		return std::nullopt;
+	return out;
+}
+
+void font_set(GtkFontDialogButton *b, const std::optional<std::string> &v) {
+	if (!v)
+		return;
+	PangoFontDescription *d = pango_font_description_from_string(v->c_str());
+	gtk_font_dialog_button_set_font_desc(b, d);
+	pango_font_description_free(d);
+}
+
+/* Collect the current settings from all widgets (forward declaration so the
+ * preview can render the live, unsaved state). */
+struct Ui;
+wb::WayboxSettings collect(Ui *ui);
+
+void to_cairo(cairo_t *cr, const wb::Color &c) {
+	cairo_set_source_rgba(cr, c.r / 255.0, c.g / 255.0, c.b / 255.0,
+			c.a / 255.0);
+}
+
+/* Draw one of the three glyph shapes (iconify, maximize, close) centred in a
+ * square, in the given colour. */
+void preview_glyph(cairo_t *cr, double cx, double cy, double s, int kind,
+		const wb::Color &fg) {
+	to_cairo(cr, fg);
+	cairo_set_line_width(cr, 1.5);
+	if (kind == 0) {  /* iconify: bottom line */
+		cairo_move_to(cr, cx - s, cy + s);
+		cairo_line_to(cr, cx + s, cy + s);
+	} else if (kind == 1) {  /* maximize: square */
+		cairo_rectangle(cr, cx - s, cy - s, 2 * s, 2 * s);
+	} else {  /* close: X */
+		cairo_move_to(cr, cx - s, cy - s);
+		cairo_line_to(cr, cx + s, cy + s);
+		cairo_move_to(cr, cx + s, cy - s);
+		cairo_line_to(cr, cx - s, cy + s);
+	}
+	cairo_stroke(cr);
+}
+
+/* Draw a single titlebar sample (active or inactive) with the theme's colours
+ * and label font, plus the three window buttons. Returns the height drawn. */
+int preview_titlebar(cairo_t *cr, const wb::Theme &theme, bool active,
+		int x, int y, int w, const char *title) {
+	wb::FrameStyle fs = wb::frame_style_from_theme(theme, active);
+	int text_h = wb::measure_text("Ag", fs.label.font).height;
+	int pad = std::max(theme.padding_y, 3);
+	int h = text_h + 2 * pad;
+	if (h < 18)
+		h = 18;
+
+	/* border + titlebar fill */
+	to_cairo(cr, fs.border.color);
+	cairo_rectangle(cr, x - 1, y - 1, w + 2, h + 2);
+	cairo_fill(cr);
+	wb::paint_fill(cr, x, y, w, h, fs.title_bar.fill);
+
+	/* label */
+	int ty = y + (h - text_h) / 2;
+	wb::paint_text(cr, x + 6, ty, title, fs.label.color, fs.label.font);
+
+	/* three buttons on the right */
+	int bs = (h * 2) / 3;
+	int by = y + (h - bs) / 2;
+	int bx = x + w - 6 - 3 * (bs + 2);
+	const wb::StateStyle &btn = fs.button.for_state(wb::WidgetState::Normal);
+	for (int i = 0; i < 3; i++) {
+		int cx = bx + i * (bs + 2) + bs / 2;
+		preview_glyph(cr, cx, by + bs / 2.0, bs * 0.28, i, btn.fg);
+	}
+	return h;
+}
+
+void preview_draw(GtkDrawingArea *, cairo_t *cr, int width, int height,
+		gpointer data) {
+	Ui *ui = static_cast<Ui *>(data);
+	wb::WayboxSettings s = collect(ui);
+
+	/* Resolve the theme being previewed (the live selection), with the live
+	 * font overrides applied on top. */
+	wb::Theme theme = s.theme_name ? wb::load_theme(*s.theme_name)
+			: wb::default_theme();
+	auto apply_font = [](const std::optional<std::string> &v, wb::FontSpec &f) {
+		if (!v)
+			return;
+		PangoFontDescription *d = pango_font_description_from_string(v->c_str());
+		if (const char *fam = pango_font_description_get_family(d))
+			f.family = fam;
+		int sz = pango_font_description_get_size(d);
+		if (sz > 0)
+			f.size_pt = pango_font_description_get_size_is_absolute(d)
+					? sz / PANGO_SCALE
+					: sz / PANGO_SCALE;
+		f.bold = pango_font_description_get_weight(d) >= PANGO_WEIGHT_BOLD;
+		pango_font_description_free(d);
+	};
+	apply_font(s.font_active_window, theme.font_active_title);
+	apply_font(s.font_inactive_window, theme.font_inactive_title);
+	apply_font(s.font_menu_item, theme.font_menu_item);
+	apply_font(s.font_osd, theme.font_osd);
+
+	/* Backdrop. */
+	cairo_set_source_rgb(cr, 0.18, 0.18, 0.2);
+	cairo_rectangle(cr, 0, 0, width, height);
+	cairo_fill(cr);
+
+	int margin = 12;
+	int w = width - 2 * margin;
+	int y = margin;
+	y += preview_titlebar(cr, theme, true, margin, y, w, _("Active window")) + 4;
+	/* a thin client area below the active titlebar */
+	cairo_set_source_rgb(cr, 0.93, 0.93, 0.93);
+	cairo_rectangle(cr, margin, y, w, 26);
+	cairo_fill(cr);
+	y += 26 + 12;
+	y += preview_titlebar(cr, theme, false, margin, y, w, _("Inactive window")) + 4;
+
+	/* A small menu sample. */
+	wb::MenuStyle ms = wb::menu_style_from_theme(theme);
+	y += 12;
+	int mh = wb::measure_text("Ag", ms.item_text.font).height + 6;
+	const char *items[] = {_("Terminal"), _("Web Browser"), _("Files")};
+	int mw = w / 2;
+	for (int i = 0; i < 3; i++) {
+		bool hot = (i == 1);
+		const wb::StateStyle &st = ms.item.for_state(
+				hot ? wb::WidgetState::Hover : wb::WidgetState::Normal);
+		wb::paint_fill(cr, margin, y, mw, mh, st.fill);
+		wb::paint_text(cr, margin + 8, y + 3, items[i], st.fg,
+				ms.item_text.font);
+		y += mh;
+	}
+}
+
+void preview_refresh(Ui *ui) {
+	if (ui->preview != nullptr)
+		gtk_widget_queue_draw(ui->preview);
+}
 
 void populate(Ui *ui, const wb::WayboxSettings &s) {
 	/* Theme list: every installed theme, current one guaranteed present and
@@ -293,6 +466,14 @@ void populate(Ui *ui, const wb::WayboxSettings &s) {
 			index_of(kOrder, s.switcher_order.value_or("mru"), 0));
 	gtk_switch_set_active(ui->switcher_osd, s.switcher_osd.value_or(true));
 	gtk_switch_set_active(ui->switcher_wrap, s.switcher_wrap.value_or(true));
+
+	font_set(ui->font_active, s.font_active_window);
+	font_set(ui->font_inactive, s.font_inactive_window);
+	font_set(ui->font_menu_header, s.font_menu_header);
+	font_set(ui->font_menu_item, s.font_menu_item);
+	font_set(ui->font_osd, s.font_osd);
+
+	preview_refresh(ui);
 }
 
 /* ---- Collect widget state back into a WayboxSettings ----------------- */
@@ -324,6 +505,12 @@ wb::WayboxSettings collect(Ui *ui) {
 	s.switcher_order = kOrder[gtk_drop_down_get_selected(ui->switcher_order)];
 	s.switcher_osd = gtk_switch_get_active(ui->switcher_osd);
 	s.switcher_wrap = gtk_switch_get_active(ui->switcher_wrap);
+
+	s.font_active_window = font_value(ui->font_active);
+	s.font_inactive_window = font_value(ui->font_inactive);
+	s.font_menu_header = font_value(ui->font_menu_header);
+	s.font_menu_item = font_value(ui->font_menu_item);
+	s.font_osd = font_value(ui->font_osd);
 	return s;
 }
 
@@ -375,8 +562,37 @@ GtkWidget *build_theme_page(Ui *ui) {
 	GtkWidget *list = gtk_list_box_new();
 	gtk_list_box_set_selection_mode(GTK_LIST_BOX(list), GTK_SELECTION_BROWSE);
 	ui->theme_list = GTK_LIST_BOX(list);
+	g_signal_connect_swapped(list, "selected-rows-changed",
+			G_CALLBACK(preview_refresh), ui);
 	gtk_scrolled_window_set_child(GTK_SCROLLED_WINDOW(scroller), list);
 	gtk_box_append(GTK_BOX(content), scroller);
+
+	/* Live preview pane below the theme list. */
+	GtkWidget *pcontent = section(page, _("Preview"));
+	GtkWidget *area = gtk_drawing_area_new();
+	gtk_widget_set_size_request(area, -1, 230);
+	gtk_drawing_area_set_draw_func(GTK_DRAWING_AREA(area), preview_draw, ui,
+			nullptr);
+	ui->preview = area;
+	gtk_box_append(GTK_BOX(pcontent), area);
+	return page;
+}
+
+GtkWidget *build_fonts_page(Ui *ui) {
+	GtkWidget *page = make_page();
+	GtkWidget *content = section(page, _("Fonts"));
+	GtkWidget *grid = section_grid(content);
+	ui->font_active = add_font(grid, 0, _("Active window title:"));
+	ui->font_inactive = add_font(grid, 1, _("Inactive window title:"));
+	ui->font_menu_header = add_font(grid, 2, _("Menu header:"));
+	ui->font_menu_item = add_font(grid, 3, _("Menu item:"));
+	ui->font_osd = add_font(grid, 4, _("On-screen display:"));
+	/* Refresh the preview whenever a font changes. */
+	for (GtkFontDialogButton *b : {ui->font_active, ui->font_inactive,
+			ui->font_menu_header, ui->font_menu_item, ui->font_osd}) {
+		g_signal_connect_swapped(b, "notify::font-desc",
+				G_CALLBACK(preview_refresh), ui);
+	}
 	return page;
 }
 
@@ -460,6 +676,7 @@ void build_window(GtkApplication *app, Ui *ui) {
 
 	add_tab(notebook, build_theme_page(ui), _("Theme"));
 	add_tab(notebook, build_appearance_page(ui), _("Appearance"));
+	add_tab(notebook, build_fonts_page(ui), _("Fonts"));
 	add_tab(notebook, build_windows_page(ui), _("Windows"));
 	add_tab(notebook, build_margins_page(ui), _("Margins"));
 	add_tab(notebook, build_menu_page(ui), _("Menu"));
diff --git a/wbconf/meson.build b/wbconf/meson.build
index 5df9442..57cadeb 100644
--- a/wbconf/meson.build
+++ b/wbconf/meson.build
@@ -10,9 +10,10 @@ wbconf_args = [
 
 executable(
   'wbconf',
-  ['main.cpp', files('../waybox/wbconf.cpp'), theme_src],
+  ['main.cpp', files('../waybox/wbconf.cpp'), theme_src, style_src, widget_src,
+   render_src],
   include_directories: [inc_dir],
-  dependencies: [gtk4, libxml2],
+  dependencies: [gtk4, libxml2, cairo, pango, pangocairo],
   cpp_args: wbconf_args,
   install: true,
 )