feat(qt): add interactive DonutChart widget

Author: kwvg

src/Makefile.qt.include

@@ -63,6 +63,7 @@ QT_MOC_CPP = \
   qt/moc_createwalletdialog.cpp \
   qt/moc_csvmodelwriter.cpp \
   qt/moc_descriptiondialog.cpp \
+  qt/moc_donutchart.cpp \
   qt/moc_editaddressdialog.cpp \
   qt/moc_guiutil.cpp \
   qt/moc_informationwidget.cpp \
@@ -147,6 +148,7 @@ BITCOIN_QT_H = \
   qt/createwalletdialog.h \
   qt/csvmodelwriter.h \
   qt/descriptiondialog.h \
+  qt/donutchart.h \
   qt/editaddressdialog.h \
   qt/guiconstants.h \
   qt/guiutil_font.h \
@@ -254,19 +256,19 @@ BITCOIN_QT_BASE_CPP = \
   qt/bantablemodel.cpp \
   qt/bitcoin.cpp \
   qt/bitcoinaddressvalidator.cpp \
-  qt/masternodemodel.cpp \
-  qt/proposalmodel.cpp \
   qt/bitcoinamountfield.cpp \
   qt/bitcoingui.cpp \
   qt/bitcoinunits.cpp \
   qt/clientfeeds.cpp \
   qt/clientmodel.cpp \
   qt/csvmodelwriter.cpp \
+  qt/donutchart.cpp \
   qt/guiutil.cpp \
   qt/guiutil_font.cpp \
   qt/informationwidget.cpp \
   qt/initexecutor.cpp \
   qt/intro.cpp \
+  qt/masternodemodel.cpp \
   qt/modaloverlay.cpp \
   qt/networkstyle.cpp \
   qt/networkwidget.cpp \
@@ -276,6 +278,7 @@ BITCOIN_QT_BASE_CPP = \
   qt/peertablemodel.cpp \
   qt/peertablesortproxy.cpp \
   qt/proposalinfo.cpp \
+  qt/proposalmodel.cpp \
   qt/qvalidatedlineedit.cpp \
   qt/qvaluecombobox.cpp \
   qt/rpcconsole.cpp \

src/qt/donutchart.cpp

@@ -0,0 +1,228 @@
+// Copyright (c) 2026 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#include <qt/donutchart.h>
+
+#include <qt/guiutil.h>
+
+#include <QMouseEvent>
+#include <QPainter>
+#include <QtMath>
+
+namespace {
+constexpr int CHART_MARGIN{10};
+constexpr int TEXT_PADDING{20};
+} // anonymous namespace
+
+DonutChart::DonutChart(QWidget* parent)
+    : QWidget(parent)
+{
+    setMouseTracking(true);
+    setAttribute(Qt::WA_Hover);
+}
+
+DonutChart::~DonutChart() = default;
+
+void DonutChart::setData(std::vector<Slice>&& slices, double total_capacity, CenterText&& default_text)
+{
+    m_slices = std::move(slices);
+    m_total_capacity = total_capacity;
+    m_default_center_text = std::move(default_text);
+    m_hovered_slice = -1;
+    update();
+}
+
+void DonutChart::clear()
+{
+    m_slices.clear();
+    m_total_capacity = 0;
+    m_hovered_slice = -1;
+    m_default_center_text = {};
+    update();
+}
+
+QSize DonutChart::sizeHint() const
+{
+    return QSize(200, 200);
+}
+
+QSize DonutChart::minimumSizeHint() const
+{
+    return QSize(150, 150);
+}
+
+DonutChart::Geometry DonutChart::chartGeometry() const
+{
+    const int effective_height{static_cast<int>(height() * 0.8)};
+    const int side{qMin(width(), effective_height) - 2 * CHART_MARGIN};
+    const int outer_radius{qMax(0, side / 2)};
+    const int donut_thickness{qBound(25, outer_radius / 4, 60)};
+    return {
+        .m_inner_radius = qMax(0, outer_radius - donut_thickness),
+        .m_outer_radius = outer_radius,
+        .m_center = {width() / 2, height() / 2}
+    };
+}
+
+void DonutChart::paintEvent(QPaintEvent* /*event*/)
+{
+    QPainter painter{this};
+    painter.setRenderHint(QPainter::Antialiasing);
+
+    const auto [inner_radius, outer_radius, center] = chartGeometry();
+    if (outer_radius <= 0) return;
+
+    // Draw background circle (unallocated portion)
+    painter.setPen(Qt::NoPen);
+    painter.setBrush(GUIUtil::getThemedQColor(GUIUtil::ThemedColor::BORDER_WIDGET));
+    painter.drawEllipse(center, outer_radius, outer_radius);
+
+    // Draw slices (clamped so total never exceeds 360 degrees)
+    if (m_total_capacity > 0 && !m_slices.empty()) {
+        int start_angle{90 * 16}; // Start from top (Qt uses 1/16th of a degree)
+        int remaining_angle{360 * 16};
+        for (size_t idx{0}; idx < m_slices.size(); idx++) {
+            if (remaining_angle <= 0) break;
+            const auto& slice = m_slices[idx];
+            if (slice.m_value <= 0) continue;
+            const double fraction{slice.m_value / m_total_capacity};
+            const int span_angle{std::max(-(remaining_angle), static_cast<int>(-fraction * 360 * 16))}; // Negative for clockwise
+            QColor color{slice.m_color};
+            if (static_cast<int>(idx) == m_hovered_slice) {
+                color = color.lighter(130);
+            }
+            painter.setBrush(color);
+            painter.drawPie(center.x() - outer_radius, center.y() - outer_radius,
+                            outer_radius * 2, outer_radius * 2, start_angle, span_angle);
+            start_angle += span_angle;
+            remaining_angle += span_angle; // span_angle is negative
+        }
+    }
+
+    // Draw inner circle
+    painter.setBrush(GUIUtil::getThemedQColor(GUIUtil::ThemedColor::BACKGROUND_WIDGET));
+    painter.drawEllipse(center, inner_radius, inner_radius);
+
+    // Draw center text
+    painter.setPen(GUIUtil::getThemedQColor(GUIUtil::ThemedColor::DEFAULT));
+
+    QString line1, line2, line3;
+    if (m_hovered_slice >= 0 && m_hovered_slice < static_cast<int>(m_slices.size())) {
+        const auto& slice = m_slices[m_hovered_slice];
+        line1 = slice.m_donut_center_label;
+        line2 = slice.m_donut_sub_label1;
+        line3 = slice.m_donut_sub_label2;
+    } else {
+        line1 = m_default_center_text.m_donut_center_label;
+        line2 = m_default_center_text.m_donut_sub_label1;
+        line3 = m_default_center_text.m_donut_sub_label2;
+    }
+
+    // Calculate font sizes to fit in the inner circle - scale with widget size
+    const int max_text_width{inner_radius * 2 - TEXT_PADDING};
+    QFont font{painter.font()};
+
+    // Scale font sizes based on inner radius (min 8pt, max reasonable sizes)
+    const int primary_font_size{qBound(9, inner_radius * 11 / 60, 20)};
+    const int secondary_font_size{qBound(8, inner_radius * 11 / 80, 15)};
+
+    // Line 1 (name or allocated amount) - larger
+    font.setPointSize(primary_font_size);
+    font.setBold(true);
+    painter.setFont(font);
+    QFontMetrics fm1{font};
+    QString elided_line1{fm1.elidedText(line1, Qt::ElideRight, max_text_width)};
+
+    // Lines 2 and 3 - smaller
+    font.setPointSize(secondary_font_size);
+    font.setBold(false);
+    painter.setFont(font);
+    QFontMetrics fm2{font};
+
+    const int line_height{fm2.height()};
+    const int total_height{fm1.height() + line_height * 2 + 4};
+    int y{center.y() - total_height / 2};
+
+    // Draw line 1
+    font.setPointSize(primary_font_size);
+    font.setBold(true);
+    painter.setFont(font);
+    painter.drawText(QRect(center.x() - max_text_width / 2, y, max_text_width, fm1.height()),
+                     Qt::AlignCenter, elided_line1);
+    y += fm1.height() + 2;
+
+    // Draw lines 2 and 3
+    font.setPointSize(secondary_font_size);
+    font.setBold(false);
+    painter.setFont(font);
+    const QString elided_line2{fm2.elidedText(line2, Qt::ElideRight, max_text_width)};
+    const QString elided_line3{fm2.elidedText(line3, Qt::ElideRight, max_text_width)};
+    painter.drawText(QRect(center.x() - max_text_width / 2, y, max_text_width, line_height),
+                     Qt::AlignCenter, elided_line2);
+    y += line_height;
+    painter.drawText(QRect(center.x() - max_text_width / 2, y, max_text_width, line_height),
+                     Qt::AlignCenter, elided_line3);
+}
+
+int DonutChart::sliceAtPosition(const QPoint& pos) const
+{
+    if (m_slices.empty() || m_total_capacity <= 0) {
+        return -1;
+    }
+
+    const auto [inner_radius, outer_radius, center] = chartGeometry();
+
+    // Check if point is within the donut ring
+    const int dx{pos.x() - center.x()};
+    const int dy{pos.y() - center.y()};
+    const double dist{qSqrt(dx * dx + dy * dy)};
+
+    if (dist < inner_radius || dist > outer_radius) {
+        return -1;
+    }
+
+    // Calculate angle (0 = top, clockwise)
+    // Note: swapped and negated for top=0, clockwise
+    double angle{qAtan2(dx, -dy)};
+    if (angle < 0) {
+        angle += 2 * M_PI;
+    }
+
+    // Find which slice this angle falls into.
+    // Mirror paintEvent's clamping so hit-regions match what is painted.
+    double current_angle{0};
+    double remaining{2 * M_PI};
+    for (size_t idx{0}; idx < m_slices.size(); idx++) {
+        if (remaining <= 0) break;
+        if (m_slices[idx].m_value <= 0) continue;
+        const double fraction{m_slices[idx].m_value / m_total_capacity};
+        const double slice_angle{std::min(fraction * 2 * M_PI, remaining)};
+        if (angle >= current_angle && angle < current_angle + slice_angle) {
+            return static_cast<int>(idx);
+        }
+        current_angle += slice_angle;
+        remaining -= slice_angle;
+    }
+
+    return -1;
+}
+
+void DonutChart::mouseMoveEvent(QMouseEvent* event)
+{
+    const int slice{sliceAtPosition(event->pos())};
+    if (slice != m_hovered_slice) {
+        m_hovered_slice = slice;
+        update();
+    }
+    QWidget::mouseMoveEvent(event);
+}
+
+void DonutChart::leaveEvent(QEvent* event)
+{
+    if (m_hovered_slice != -1) {
+        m_hovered_slice = -1;
+        update();
+    }
+    QWidget::leaveEvent(event);
+}

src/qt/donutchart.h

@@ -0,0 +1,62 @@
+// Copyright (c) 2026 The Dash Core developers
+// Distributed under the MIT software license, see the accompanying
+// file COPYING or http://www.opensource.org/licenses/mit-license.php.
+
+#ifndef BITCOIN_QT_DONUTCHART_H
+#define BITCOIN_QT_DONUTCHART_H
+
+#include <QWidget>
+
+#include <vector>
+
+class DonutChart : public QWidget
+{
+    Q_OBJECT
+
+public:
+    struct Slice {
+        double m_value{0.0};
+        QColor m_color;
+        QString m_donut_center_label;
+        QString m_donut_sub_label1;
+        QString m_donut_sub_label2;
+    };
+
+    struct CenterText {
+        QString m_donut_center_label;
+        QString m_donut_sub_label1;
+        QString m_donut_sub_label2;
+    };
+
+    explicit DonutChart(QWidget* parent = nullptr);
+    ~DonutChart() override;
+
+    void setData(std::vector<Slice>&& slices, double total_capacity, CenterText&& default_text);
+    void clear();
+
+    QSize sizeHint() const override;
+    QSize minimumSizeHint() const override;
+
+protected:
+    void paintEvent(QPaintEvent* event) override;
+    void mouseMoveEvent(QMouseEvent* event) override;
+    void leaveEvent(QEvent* event) override;
+
+private:
+    struct Geometry {
+        int m_inner_radius;
+        int m_outer_radius;
+        QPoint m_center;
+    };
+
+    Geometry chartGeometry() const;
+    int sliceAtPosition(const QPoint& pos) const;
+
+private:
+    CenterText m_default_center_text;
+    double m_total_capacity{0};
+    int m_hovered_slice{-1};
+    std::vector<Slice> m_slices;
+};
+
+#endif // BITCOIN_QT_DONUTCHART_H

test/util/data/non-backported.txt

@@ -30,6 +30,7 @@ src/messagesigner.*
 src/netfulfilledman.*
 src/qt/clientfeeds.*
 src/qt/descriptiondialog.*
+src/qt/donutchart.*
 src/qt/guiutil_font.*
 src/qt/informationwidget.*
 src/qt/masternodelist.*