native-theme-qt 0.1.0

Resolve the active Qt 6 theme into a serializable toolkit-neutral snapshot
Documentation
#include "probe.h"

#include <QApplication>
#include <QBrush>
#include <QCheckBox>
#include <QComboBox>
#include <QCoreApplication>
#include <QFont>
#include <QFontDatabase>
#include <QGuiApplication>
#include <QIcon>
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
#include <QLineEdit>
#include <QProgressBar>
#include <QPushButton>
#include <QRadioButton>
#include <QScrollBar>
#include <QSlider>
#include <QSpinBox>
#include <QPalette>
#include <QStyle>
#include <QTabBar>
#include <QToolButton>
#include <QWidget>
#include <QtGlobal>

#include <array>
#include <cstdlib>
#include <memory>
#include <stdexcept>
#include <string>

namespace native_theme_qt {
namespace {

QJsonValue environment_value(const char *name) {
  const char *value = std::getenv(name);
  return value == nullptr ? QJsonValue(QJsonValue::Null)
                          : QJsonValue(QString::fromLocal8Bit(value));
}

QJsonObject color_json(const QColor &color) {
  return {
      {"red", color.redF()},
      {"green", color.greenF()},
      {"blue", color.blueF()},
      {"alpha", color.alphaF()},
  };
}

QJsonObject brush_json(const QBrush &brush) {
  return {
      {"color", color_json(brush.color())},
      {"brush_style", static_cast<int>(brush.style())},
  };
}

QJsonObject font_json(const QFont &font) {
  return {
      {"family", font.family()},
      {"point_size", font.pointSizeF()},
      {"pixel_size", font.pixelSize()},
      {"weight", font.weight()},
      {"italic", font.italic()},
      {"stretch", font.stretch()},
  };
}

struct PaletteRole {
  const char *name;
  QPalette::ColorRole role;
};

QJsonObject palette_json(const QPalette &palette) {
  static const std::array roles = {
      PaletteRole{"window_text", QPalette::WindowText},
      PaletteRole{"button", QPalette::Button},
      PaletteRole{"light", QPalette::Light},
      PaletteRole{"midlight", QPalette::Midlight},
      PaletteRole{"dark", QPalette::Dark},
      PaletteRole{"mid", QPalette::Mid},
      PaletteRole{"text", QPalette::Text},
      PaletteRole{"bright_text", QPalette::BrightText},
      PaletteRole{"button_text", QPalette::ButtonText},
      PaletteRole{"base", QPalette::Base},
      PaletteRole{"window", QPalette::Window},
      PaletteRole{"shadow", QPalette::Shadow},
      PaletteRole{"highlight", QPalette::Highlight},
      PaletteRole{"highlighted_text", QPalette::HighlightedText},
      PaletteRole{"link", QPalette::Link},
      PaletteRole{"link_visited", QPalette::LinkVisited},
      PaletteRole{"alternate_base", QPalette::AlternateBase},
      PaletteRole{"tooltip_base", QPalette::ToolTipBase},
      PaletteRole{"tooltip_text", QPalette::ToolTipText},
      PaletteRole{"placeholder_text", QPalette::PlaceholderText},
#if QT_VERSION >= QT_VERSION_CHECK(6, 6, 0)
      PaletteRole{"accent", QPalette::Accent},
#endif
  };
  static const std::array groups = {
      std::pair{"active", QPalette::Active},
      std::pair{"inactive", QPalette::Inactive},
      std::pair{"disabled", QPalette::Disabled},
  };

  QJsonObject result;
  for (const auto &[group_name, group] : groups) {
    QJsonObject values;
    for (const auto &[role_name, role] : roles) {
      values.insert(role_name, brush_json(palette.brush(group, role)));
    }
    result.insert(group_name, values);
  }
  return result;
}

QJsonObject size_json(const QSize &size) {
  return {
      {"width", size.width()},
      {"height", size.height()},
  };
}

QJsonObject control_json(QWidget &widget) {
  widget.ensurePolished();
  return {
      {"size_hint", size_json(widget.sizeHint())},
      {"minimum_size_hint", size_json(widget.minimumSizeHint())},
      {"font", font_json(widget.font())},
      {"palette", palette_json(widget.palette())},
  };
}

QJsonObject controls_json() {
  QPushButton button(QStringLiteral("Button"));
  QLineEdit line_edit(QStringLiteral("Text"));
  QCheckBox check_box(QStringLiteral("Check box"));
  QRadioButton radio_button(QStringLiteral("Radio button"));
  QComboBox combo_box;
  combo_box.addItem(QStringLiteral("Item"));
  QSpinBox spin_box;
  QSlider slider(Qt::Horizontal);
  QProgressBar progress_bar;
  progress_bar.setValue(50);
  QScrollBar scroll_bar(Qt::Vertical);
  QTabBar tab_bar;
  tab_bar.addTab(QStringLiteral("Tab"));
  QToolButton tool_button;
  tool_button.setText(QStringLiteral("Tool"));

  QJsonObject result;
  result.insert("button", control_json(button));
  result.insert("line_edit", control_json(line_edit));
  result.insert("check_box", control_json(check_box));
  result.insert("radio_button", control_json(radio_button));
  result.insert("combo_box", control_json(combo_box));
  result.insert("spin_box", control_json(spin_box));
  result.insert("slider", control_json(slider));
  result.insert("progress_bar", control_json(progress_bar));
  result.insert("scroll_bar", control_json(scroll_bar));
  result.insert("tab_bar", control_json(tab_bar));
  result.insert("tool_button", control_json(tool_button));
  return result;
}

struct PixelMetric {
  const char *name;
  QStyle::PixelMetric metric;
};

QJsonObject metrics_json(const QStyle &style) {
  static const std::array metrics = {
      PixelMetric{"button_margin", QStyle::PM_ButtonMargin},
      PixelMetric{"default_frame_width", QStyle::PM_DefaultFrameWidth},
      PixelMetric{"spinbox_frame_width", QStyle::PM_SpinBoxFrameWidth},
      PixelMetric{"combobox_frame_width", QStyle::PM_ComboBoxFrameWidth},
      PixelMetric{"scrollbar_extent", QStyle::PM_ScrollBarExtent},
      PixelMetric{"scrollbar_slider_min", QStyle::PM_ScrollBarSliderMin},
      PixelMetric{"slider_thickness", QStyle::PM_SliderThickness},
      PixelMetric{"slider_control_thickness", QStyle::PM_SliderControlThickness},
      PixelMetric{"slider_length", QStyle::PM_SliderLength},
      PixelMetric{"indicator_width", QStyle::PM_IndicatorWidth},
      PixelMetric{"indicator_height", QStyle::PM_IndicatorHeight},
      PixelMetric{"exclusive_indicator_width", QStyle::PM_ExclusiveIndicatorWidth},
      PixelMetric{"exclusive_indicator_height", QStyle::PM_ExclusiveIndicatorHeight},
      PixelMetric{"tab_horizontal_space", QStyle::PM_TabBarTabHSpace},
      PixelMetric{"tab_vertical_space", QStyle::PM_TabBarTabVSpace},
      PixelMetric{"tabbar_base_height", QStyle::PM_TabBarBaseHeight},
      PixelMetric{"toolbar_icon_size", QStyle::PM_ToolBarIconSize},
      PixelMetric{"small_icon_size", QStyle::PM_SmallIconSize},
      PixelMetric{"large_icon_size", QStyle::PM_LargeIconSize},
      PixelMetric{"listview_icon_size", QStyle::PM_ListViewIconSize},
      PixelMetric{"layout_left_margin", QStyle::PM_LayoutLeftMargin},
      PixelMetric{"layout_top_margin", QStyle::PM_LayoutTopMargin},
      PixelMetric{"layout_right_margin", QStyle::PM_LayoutRightMargin},
      PixelMetric{"layout_bottom_margin", QStyle::PM_LayoutBottomMargin},
      PixelMetric{"layout_horizontal_spacing", QStyle::PM_LayoutHorizontalSpacing},
      PixelMetric{"layout_vertical_spacing", QStyle::PM_LayoutVerticalSpacing},
      PixelMetric{"menu_button_indicator", QStyle::PM_MenuButtonIndicator},
      PixelMetric{"menu_panel_width", QStyle::PM_MenuPanelWidth},
  };

  QJsonObject result;
  for (const auto &[name, metric] : metrics) {
    result.insert(name, style.pixelMetric(metric));
  }
  return result;
}

struct StyleHint {
  const char *name;
  QStyle::StyleHint hint;
};

QJsonObject hints_json(const QStyle &style) {
  static const std::array hints = {
      StyleHint{"underline_shortcut", QStyle::SH_UnderlineShortcut},
      StyleHint{"dialog_button_layout", QStyle::SH_DialogButtonLayout},
      StyleHint{"submenu_popup_delay_ms", QStyle::SH_Menu_SubMenuPopupDelay},
      StyleHint{"scrollbar_left_click_absolute", QStyle::SH_ScrollBar_LeftClickAbsolutePosition},
      StyleHint{"scrollbar_middle_click_absolute", QStyle::SH_ScrollBar_MiddleClickAbsolutePosition},
      StyleHint{"activate_item_on_single_click", QStyle::SH_ItemView_ActivateItemOnSingleClick},
      StyleHint{"widget_animate", QStyle::SH_Widget_Animate},
  };

  QJsonObject result;
  for (const auto &[name, hint] : hints) {
    result.insert(name, style.styleHint(hint));
  }
  return result;
}

} // namespace

std::unique_ptr<std::string> probe_theme() {
  std::unique_ptr<QApplication> owned_application;
  if (QCoreApplication::instance() == nullptr) {
    static int argc = 1;
    static char program_name[] = "native-theme-qt";
    static char *argv[] = {program_name, nullptr};
    owned_application = std::make_unique<QApplication>(argc, argv);
  } else if (qobject_cast<QApplication *>(QCoreApplication::instance()) == nullptr) {
    throw std::runtime_error(
        "a non-QApplication QCoreApplication already exists; run the probe in a subprocess");
  }

  auto *application = qobject_cast<QApplication *>(QCoreApplication::instance());
  if (application == nullptr || application->style() == nullptr) {
    throw std::runtime_error("Qt did not initialize an application style");
  }
  const QStyle &style = *application->style();

  QJsonObject root{
      {"schema_version", 1},
      {"backend", "qt6"},
      {"identity",
       QJsonObject{
           {"style_name", style.name()},
           {"toolkit_version", qVersion()},
           {"platform_backend", QGuiApplication::platformName()},
           {"platform_theme", environment_value("QT_QPA_PLATFORMTHEME")},
           {"style_override", environment_value("QT_STYLE_OVERRIDE")},
       }},
      {"settings",
       QJsonObject{
           {"font", font_json(application->font())},
           {"fixed_font", font_json(QFontDatabase::systemFont(QFontDatabase::FixedFont))},
           {"icon_theme_name", QIcon::themeName()},
           {"cursor_flash_time_ms", application->cursorFlashTime()},
           {"double_click_interval_ms", application->doubleClickInterval()},
           {"wheel_scroll_lines", application->wheelScrollLines()},
           {"application_stylesheet", application->styleSheet()},
       }},
      {"palette", palette_json(application->palette())},
      {"controls", controls_json()},
      {"metrics", metrics_json(style)},
      {"hints", hints_json(style)},
      {"diagnostics", QJsonArray{}},
  };

  const QByteArray bytes = QJsonDocument(root).toJson(QJsonDocument::Compact);
  return std::make_unique<std::string>(bytes.constData(), bytes.size());
}

} // namespace native_theme_qt