#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;
}
}
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());
}
}