feat(qt): UI refresh (2/n, update "Governance" Tab layout, lifecycle icons, description dialogs, resumable proposal creation)

src/governance/governance.cpp

@@ -15,6 +15,7 @@
 #include <governance/validators.h>
 #include <masternode/meta.h>
 #include <masternode/sync.h>
+#include <node/interface_ui.h>
 #include <protocol.h>
 #include <shutdown.h>
 #include <spork.h>
@@ -318,6 +319,7 @@ void CGovernanceManager::AddGovernanceObjectInternal(CGovernanceObject& insert_o
 
     // SEND NOTIFICATION TO SCRIPT/ZMQ
     GetMainSignals().NotifyGovernanceObject(std::make_shared<const Governance::Object>(govobj->Object()), nHash.ToString());
+    uiInterface.NotifyGovernanceChanged();
 }
 
 void CGovernanceManager::AddGovernanceObject(CGovernanceObject& govobj, const CNode* pfrom)

src/governance/object.cpp

@@ -15,6 +15,7 @@
 #include <core_io.h>
 #include <index/txindex.h>
 #include <logging.h>
+#include <node/interface_ui.h>
 #include <timedata.h>
 #include <util/time.h>
 #include <validation.h>
@@ -155,6 +156,7 @@ bool CGovernanceObject::ProcessVote(CMasternodeMetaMan& mn_metaman, CGovernanceM
     // SEND NOTIFICATION TO SCRIPT/ZMQ
     GetMainSignals().NotifyGovernanceVote(std::make_shared<CDeterministicMNList>(tip_mn_list),
                                           std::make_shared<const CGovernanceVote>(vote), vote.GetHash().ToString());
+    uiInterface.NotifyGovernanceChanged();
     return true;
 }
 

src/interfaces/node.h

@@ -466,6 +466,10 @@ class Node
         std::function<void(SynchronizationState, interfaces::BlockTip tip, double verification_progress)>;
     virtual std::unique_ptr<Handler> handleNotifyHeaderTip(NotifyHeaderTipFn fn) = 0;
 
+    //! Register handler for governance data messages.
+    using NotifyGovernanceChangedFn = std::function<void()>;
+    virtual std::unique_ptr<Handler> handleNotifyGovernanceChanged(NotifyGovernanceChangedFn fn) = 0;
+
     //! Register handler for masternode list update messages.
     using NotifyMasternodeListChangedFn =
         std::function<void(const CDeterministicMNList& newList,

src/node/interface_ui.cpp

@@ -23,6 +23,7 @@ struct UISignals {
     boost::signals2::signal<CClientUIInterface::NotifyBlockTipSig> NotifyBlockTip;
     boost::signals2::signal<CClientUIInterface::NotifyChainLockSig> NotifyChainLock;
     boost::signals2::signal<CClientUIInterface::NotifyHeaderTipSig> NotifyHeaderTip;
+    boost::signals2::signal<CClientUIInterface::NotifyGovernanceChangedSig> NotifyGovernanceChanged;
     boost::signals2::signal<CClientUIInterface::NotifyMasternodeListChangedSig> NotifyMasternodeListChanged;
     boost::signals2::signal<CClientUIInterface::NotifyAdditionalDataSyncProgressChangedSig> NotifyAdditionalDataSyncProgressChanged;
     boost::signals2::signal<CClientUIInterface::BannedListChangedSig> BannedListChanged;
@@ -46,6 +47,7 @@ ADD_SIGNALS_IMPL_WRAPPER(ShowProgress);
 ADD_SIGNALS_IMPL_WRAPPER(NotifyBlockTip);
 ADD_SIGNALS_IMPL_WRAPPER(NotifyChainLock);
 ADD_SIGNALS_IMPL_WRAPPER(NotifyHeaderTip);
+ADD_SIGNALS_IMPL_WRAPPER(NotifyGovernanceChanged);
 ADD_SIGNALS_IMPL_WRAPPER(NotifyMasternodeListChanged);
 ADD_SIGNALS_IMPL_WRAPPER(NotifyAdditionalDataSyncProgressChanged);
 ADD_SIGNALS_IMPL_WRAPPER(BannedListChanged);
@@ -61,6 +63,7 @@ void CClientUIInterface::ShowProgress(const std::string& title, int nProgress, b
 void CClientUIInterface::NotifyBlockTip(SynchronizationState s, const CBlockIndex* i) { return g_ui_signals.NotifyBlockTip(s, i); }
 void CClientUIInterface::NotifyChainLock(const std::string& bestChainLockHash, int bestChainLockHeight) { return g_ui_signals.NotifyChainLock(bestChainLockHash, bestChainLockHeight); }
 void CClientUIInterface::NotifyHeaderTip(SynchronizationState s, const CBlockIndex* i) { return g_ui_signals.NotifyHeaderTip(s, i); }
+void CClientUIInterface::NotifyGovernanceChanged() { return g_ui_signals.NotifyGovernanceChanged(); }
 void CClientUIInterface::NotifyMasternodeListChanged(const CDeterministicMNList& list, const CBlockIndex* i) { return g_ui_signals.NotifyMasternodeListChanged(list, i); }
 void CClientUIInterface::NotifyAdditionalDataSyncProgressChanged(double nSyncProgress) { return g_ui_signals.NotifyAdditionalDataSyncProgressChanged(nSyncProgress); }
 void CClientUIInterface::BannedListChanged() { return g_ui_signals.BannedListChanged(); }

src/node/interface_ui.h

@@ -115,6 +115,9 @@ class CClientUIInterface
     /** Masternode list has changed */
     ADD_SIGNALS_DECL_WRAPPER(NotifyMasternodeListChanged, void, const CDeterministicMNList&, const CBlockIndex*);
 
+    /** Governance data changed */
+    ADD_SIGNALS_DECL_WRAPPER(NotifyGovernanceChanged, void);
+
     /** Additional data sync progress changed */
     ADD_SIGNALS_DECL_WRAPPER(NotifyAdditionalDataSyncProgressChanged, void, double nSyncProgress);
 

src/node/interfaces.cpp

@@ -858,6 +858,10 @@ class NodeImpl : public Node
                     /* verification progress is unused when a header was received */ 0);
             }));
     }
+    std::unique_ptr<Handler> handleNotifyGovernanceChanged(NotifyGovernanceChangedFn fn) override
+    {
+        return MakeHandler(::uiInterface.NotifyGovernanceChanged_connect(fn));
+    }
     std::unique_ptr<Handler> handleNotifyMasternodeListChanged(NotifyMasternodeListChangedFn fn) override
     {
         return MakeHandler(

src/qt/clientmodel.cpp

@@ -321,6 +321,10 @@ void ClientModel::subscribeToCoreSignals()
         [this](const CDeterministicMNList& newList, const CBlockIndex* pindex) {
             setMasternodeList(interfaces::MakeMNList(newList), pindex);
         }));
+    m_event_handlers.emplace_back(m_node.handleNotifyGovernanceChanged(
+        [this]() {
+            Q_EMIT governanceChanged();
+        }));
 }
 
 void ClientModel::unsubscribeFromCoreSignals()

src/qt/clientmodel.h

@@ -128,6 +128,7 @@ class ClientModel : public QObject
 
 Q_SIGNALS:
     void numConnectionsChanged(int count);
+    void governanceChanged();
     void masternodeListChanged() const;
     void chainLockChanged(const QString& bestChainLockHash, int bestChainLockHeight);
     void numBlocksChanged(int count, const QDateTime& blockDate, const QString& blockHash, double nVerificationProgress, bool header, SynchronizationState sync_state);

src/qt/governancelist.cpp

@@ -26,18 +26,20 @@
 
 #include <QAbstractItemView>
 #include <QMessageBox>
+#include <QMetaObject>
 
 //
 // Governance Tab main widget.
 //
-
 GovernanceList::GovernanceList(QWidget* parent) :
     QWidget(parent),
-    ui(std::make_unique<Ui::GovernanceList>()),
-    proposalModel(new ProposalModel(this)),
-    proposalModelProxy(new QSortFilterProxyModel(this)),
-    proposalContextMenu(new QMenu(this)),
-    timer(new QTimer(this))
+    ui{new Ui::GovernanceList},
+    proposalModel{new ProposalModel(this)},
+    proposalContextMenu{new QMenu(this)},
+    m_worker(new QObject),
+    proposalModelProxy{new QSortFilterProxyModel(this)},
+    m_thread{new QThread(this)},
+    m_timer{new QTimer(this)}
 {
     ui->setupUi(this);
 
@@ -77,31 +79,49 @@ GovernanceList::GovernanceList(QWidget* parent) :
     connect(ui->btnCreateProposal, &QPushButton::clicked, this, &GovernanceList::showCreateProposalDialog);
     connect(ui->govTableView, &QTableView::doubleClicked, this, &GovernanceList::showAdditionalInfo);
 
-    connect(timer, &QTimer::timeout, this, &GovernanceList::updateProposalList);
-
     // Initialize masternode count to 0
     ui->mnCountLabel->setText("0");
 
     GUIUtil::updateFonts();
+
+    // Background thread for calculating proposal list
+    m_worker->moveToThread(m_thread);
+    // Make sure executor object is deleted in its own thread
+    connect(m_thread, &QThread::finished, m_worker, &QObject::deleteLater);
+    m_thread->start();
+
+    // Debounce timer to apply proposal list changes
+    m_timer->setSingleShot(true);
+    connect(m_timer, &QTimer::timeout, this, &GovernanceList::updateProposalList);
 }
 
-GovernanceList::~GovernanceList() = default;
+GovernanceList::~GovernanceList()
+{
+    m_timer->stop();
+    m_thread->quit();
+    m_thread->wait();
+    delete ui;
+}
 
 void GovernanceList::setClientModel(ClientModel* model)
 {
     this->clientModel = model;
-    if (model != nullptr) {
-        connect(model->getOptionsModel(), &OptionsModel::displayUnitChanged, this, &GovernanceList::updateDisplayUnit);
-
-        updateProposalList();
+    if (clientModel) {
+        connect(clientModel, &ClientModel::governanceChanged, this, &GovernanceList::handleProposalListChanged);
+        connect(clientModel->getOptionsModel(), &OptionsModel::displayUnitChanged, this, &GovernanceList::updateDisplayUnit);
+        m_timer->start(0);
+    } else {
+        m_timer->stop();
     }
 }
 
 void GovernanceList::setWalletModel(WalletModel* model)
 {
     this->walletModel = model;
-    if (model && clientModel) {
-        updateVotingCapability();
+    if (walletModel && clientModel) {
+        m_timer->start(0);
+    } else {
+        m_timer->stop();
     }
 }
 
@@ -113,35 +133,88 @@ void GovernanceList::updateDisplayUnit()
     }
 }
 
+void GovernanceList::handleProposalListChanged()
+{
+    if (!clientModel || m_timer->isActive()) {
+        // Too early or already processing, nothing to do
+        return;
+    }
+    int delay{GOVERNANCELIST_UPDATE_SECONDS * 1000};
+    if (!clientModel->masternodeSync().isBlockchainSynced()) {
+        // Currently syncing, reduce refreshes
+        delay *= 6;
+    }
+    m_timer->start(delay);
+}
+
 void GovernanceList::updateProposalList()
 {
-    if (this->clientModel) {
-        // A proposal is considered passing if (YES votes - NO votes) >= (Total Weight of Masternodes / 10),
-        // count total valid (ENABLED) masternodes to determine passing threshold.
-        // Need to query number of masternodes here with access to clientModel.
-        const int nWeightedMnCount = clientModel->getMasternodeList().first->getValidWeightedMNsCount();
-        const int nAbsVoteReq = std::max(Params().GetConsensus().nGovernanceMinQuorum, nWeightedMnCount / 10);
-        proposalModel->setVotingParams(nAbsVoteReq);
-
-        std::vector<CGovernanceObject> govObjList;
-        clientModel->getAllGovernanceObjects(govObjList);
-        ProposalList newProposals;
-        for (const auto& govObj : govObjList) {
-            if (govObj.GetObjectType() != GovernanceObject::PROPOSAL) {
-                continue; // Skip triggers.
-            }
-            newProposals.emplace_back(std::make_unique<Proposal>(this->clientModel, govObj));
-        }
-        proposalModel->reconcile(std::move(newProposals));
+    if (!clientModel || clientModel->node().shutdownRequested()) {
+        return;
+    }
 
-        // Update voting capability if we now have both client and wallet models
-        if (walletModel) {
-            updateVotingCapability();
+    if (m_in_progress.exchange(true)) {
+        // Already applying, re-arm for next attempt
+        handleProposalListChanged();
+        return;
+    }
+
+    QMetaObject::invokeMethod(m_worker, [this] {
+        auto result = std::make_shared<CalcProposalList>(calcProposalList());
+        m_in_progress.store(false);
+        QTimer::singleShot(0, this, [this, result] {
+            setProposalList(std::move(*result));
+        });
+    });
+}
+
+GovernanceList::CalcProposalList GovernanceList::calcProposalList() const
+{
+    CalcProposalList ret;
+    if (!clientModel || clientModel->node().shutdownRequested()) {
+        return ret;
+    }
+
+    const auto [dmn, pindex] = clientModel->getMasternodeList();
+    if (!dmn || !pindex) {
+        return ret;
+    }
+
+    // A proposal is considered passing if (YES votes - NO votes) >= (Total Weight of Masternodes / 10),
+    // count total valid (ENABLED) masternodes to determine passing threshold.
+    // Need to query number of masternodes here with access to clientModel.
+    const int nWeightedMnCount = dmn->getValidWeightedMNsCount();
+    ret.m_abs_vote_req = std::max(Params().GetConsensus().nGovernanceMinQuorum, nWeightedMnCount / 10);
+
+    std::vector<CGovernanceObject> govObjList;
+    clientModel->getAllGovernanceObjects(govObjList);
+    for (const auto& govObj : govObjList) {
+        if (govObj.GetObjectType() != GovernanceObject::PROPOSAL) {
+            continue; // Skip triggers.
         }
+        ret.m_proposals.emplace_back(std::make_unique<Proposal>(this->clientModel, govObj));
     }
 
-    // Schedule next update.
-    timer->start(GOVERNANCELIST_UPDATE_SECONDS * 1000);
+    // Discover voting capability if we now have both client and wallet models
+    if (walletModel) {
+        dmn->forEachMN(/*only_valid=*/true, [&](const auto& dmn) {
+            // Check if wallet owns the voting key using the same logic as RPC
+            const auto script = GetScriptForDestination(PKHash(dmn.getKeyIdVoting()));
+            if (walletModel->wallet().isSpendable(script)) {
+                ret.m_votable_masternodes[dmn.getProTxHash()] = dmn.getKeyIdVoting();
+            }
+        });
+    }
+
+    return ret;
+}
+
+void GovernanceList::setProposalList(CalcProposalList&& data)
+{
+    proposalModel->setVotingParams(data.m_abs_vote_req);
+    proposalModel->reconcile(std::move(data.m_proposals));
+    votableMasternodes = std::move(data.m_votable_masternodes);
+    updateMasternodeCount();
 }
 
 void GovernanceList::updateProposalCount() const
@@ -213,26 +286,6 @@ void GovernanceList::showAdditionalInfo(const QModelIndex& index)
     QMessageBox::information(this, windowTitle, json);
 }
 
-void GovernanceList::updateVotingCapability()
-{
-    if (!walletModel || !clientModel) return;
-
-    auto [mn_list, pindex] = clientModel->getMasternodeList();
-    if (!pindex) return;
-
-    votableMasternodes.clear();
-    mn_list->forEachMN(/*only_valid=*/true, [&](const auto& dmn) {
-        // Check if wallet owns the voting key using the same logic as RPC
-        const CScript script = GetScriptForDestination(PKHash(dmn.getKeyIdVoting()));
-        if (walletModel->wallet().isSpendable(script)) {
-            votableMasternodes[dmn.getProTxHash()] = dmn.getKeyIdVoting();
-        }
-    });
-
-    // Update masternode count display
-    updateMasternodeCount();
-}
-
 void GovernanceList::updateMasternodeCount() const
 {
     if (ui && ui->mnCountLabel) {
@@ -340,5 +393,5 @@ void GovernanceList::voteForProposal(vote_outcome_enum_t outcome)
     QMessageBox::information(this, tr("Voting Results"), message);
 
     // Update proposal list to show new vote counts
-    updateProposalList();
+    handleProposalListChanged();
 }