DanS
db212a81c6
Replace the fill-to-height portfolio dashboard with a fine gapless grid of ~32px square cells whose column count scales to fill the tab width. The grid extends past the window and the Market tab scrolls when cards are placed lower. - Cells are a fixed square edge (>= ~32px), gapless; cards inset by 3dp so neighbours don't touch. Column count = availWidth / 32dp (min pfMinW cols). - Card minimum span is pfMinW x pfMinH (~128x96); layout/resize clamps to it. New groups default to 6x4 cells. - Content height reserves two extra rows below the lowest card so a card can be dragged past the current bottom; the scroll child grows to match. - Dot grid (shown while rearranging) softened and extended into the buffer rows. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
1643 lines
87 KiB
C++
1643 lines
87 KiB
C++
// DragonX Wallet - ImGui Edition
|
|
// Copyright 2024-2026 The Hush Developers
|
|
// Released under the GPLv3
|
|
|
|
#include "market_tab.h"
|
|
#include "../../app.h"
|
|
#include "../../config/version.h"
|
|
#include "../../data/wallet_state.h"
|
|
#include "../../config/settings.h"
|
|
#include "../../data/portfolio.h"
|
|
#include "../../data/exchange_info.h"
|
|
#include "../../util/i18n.h"
|
|
#include "../schema/ui_schema.h"
|
|
#include "../material/type.h"
|
|
#include "../material/draw_helpers.h"
|
|
#include "../material/colors.h"
|
|
#include "../material/typography.h"
|
|
#include "../material/project_icons.h"
|
|
#include "../../util/text_format.h"
|
|
#include "../../embedded/IconsMaterialDesign.h"
|
|
#include "../../util/platform.h"
|
|
#include "../layout.h"
|
|
#include "imgui.h"
|
|
|
|
#include <algorithm>
|
|
#include <cmath>
|
|
#include <ctime>
|
|
|
|
namespace dragonx {
|
|
namespace ui {
|
|
|
|
using namespace material;
|
|
|
|
// ---- Market tab persistent state ----
|
|
static std::vector<double> s_price_history; // mirror of WalletState market.price_history
|
|
static bool s_history_initialized = false;
|
|
static double s_last_refresh_time = 0.0;
|
|
|
|
// Exchange / pair selection
|
|
static int s_exchange_idx = 0;
|
|
static int s_pair_idx = 0;
|
|
static bool s_market_state_loaded = false;
|
|
|
|
// The effective exchange registry: the live CoinGecko list when available, else the
|
|
// compiled-in fallback.
|
|
static const std::vector<data::ExchangeInfo>& EffectiveRegistry(const MarketInfo& market)
|
|
{
|
|
return market.exchanges.empty() ? data::getExchangeRegistry() : market.exchanges;
|
|
}
|
|
|
|
// Helper: load selected exchange/pair from settings
|
|
static void LoadMarketState(config::Settings* settings, const std::vector<data::ExchangeInfo>& registry)
|
|
{
|
|
if (s_market_state_loaded || !settings) return;
|
|
s_market_state_loaded = true;
|
|
|
|
std::string savedExchange = settings->getSelectedExchange();
|
|
std::string savedPair = settings->getSelectedPair();
|
|
|
|
for (int ei = 0; ei < (int)registry.size(); ei++) {
|
|
if (registry[ei].name == savedExchange) {
|
|
s_exchange_idx = ei;
|
|
for (int pi = 0; pi < (int)registry[ei].pairs.size(); pi++) {
|
|
if (registry[ei].pairs[pi].displayName == savedPair) {
|
|
s_pair_idx = pi;
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Helper: format compact currency
|
|
static std::string FormatCompactUSD(double val)
|
|
{
|
|
char buf[64];
|
|
if (val >= 1e9) snprintf(buf, sizeof(buf), "$%.2fB", val / 1e9);
|
|
else if (val >= 1e6) snprintf(buf, sizeof(buf), "$%.2fM", val / 1e6);
|
|
else if (val >= 1e3) snprintf(buf, sizeof(buf), "$%.2fK", val / 1e3);
|
|
else snprintf(buf, sizeof(buf), "$%.2f", val);
|
|
return std::string(buf);
|
|
}
|
|
|
|
// Helper: format price to sensible precision
|
|
static std::string FormatPrice(double price)
|
|
{
|
|
char buf[64];
|
|
if (price >= 0.01) snprintf(buf, sizeof(buf), "$%.4f", price);
|
|
else if (price >= 0.0001) snprintf(buf, sizeof(buf), "$%.6f", price);
|
|
else snprintf(buf, sizeof(buf), "$%.8f", price);
|
|
return std::string(buf);
|
|
}
|
|
|
|
// ---- Portfolio editor (modal) state ----
|
|
static bool s_portfolio_editor_open = false;
|
|
static int s_pf_editing = -1; // -1 = list mode; -2 = adding new; >=0 = editing that index
|
|
static char s_pf_label[64] = {0};
|
|
static std::vector<std::string> s_pf_addrs;
|
|
static std::string s_pf_icon; // selected wallet-icon name ("" = none)
|
|
static unsigned int s_pf_color = 0; // selected accent (packed IM_COL32; 0 = default)
|
|
static char s_pf_search[64] = {0}; // address-list filter text
|
|
static int s_pf_type_filter = 0; // 0 = all, 1 = shielded, 2 = transparent
|
|
static bool s_pf_funded_only = false;
|
|
static float s_pf_custom_rgb[3] = {0.31f, 0.62f, 1.0f}; // working RGB for the custom color picker
|
|
// Price-data config (working copy while editing a group).
|
|
static int s_pf_price_basis = 0;
|
|
static double s_pf_manual_price = 0.0;
|
|
static char s_pf_manual_ccy[12] = "USD";
|
|
static bool s_pf_show_drgx = true;
|
|
static bool s_pf_show_value = true;
|
|
static bool s_pf_show_24h = false;
|
|
static bool s_pf_show_sparkline = false;
|
|
static int s_pf_spark_interval = 0; // 0=min 1=hour 2=day 3=week 4=month
|
|
|
|
// price_history is ~1 sample/minute; resample it to the group's chosen interval by averaging
|
|
// each block of K minute-samples into one point.
|
|
static std::vector<double> pfResampleHistory(const std::vector<double>& hist, int interval)
|
|
{
|
|
static const int kMins[5] = {1, 60, 1440, 10080, 43200};
|
|
int k = kMins[(interval >= 0 && interval < 5) ? interval : 0];
|
|
if (k <= 1) return hist;
|
|
std::vector<double> out;
|
|
for (size_t i = 0; i < hist.size(); i += (size_t)k) {
|
|
double sum = 0.0; size_t cnt = 0;
|
|
for (size_t j = i; j < hist.size() && j < i + (size_t)k; ++j) { sum += hist[j]; ++cnt; }
|
|
if (cnt) out.push_back(sum / (double)cnt);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
// A group's value trend tracks the DRGX price, so a group sparkline plots the price history
|
|
// (normalized) across a rect. Colored by overall direction. Only meaningful for market bases.
|
|
static void pfDrawSparkline(ImDrawList* dl, ImVec2 mn, ImVec2 mx,
|
|
const std::vector<double>& hist, ImU32 col)
|
|
{
|
|
int n = (int)hist.size();
|
|
if (n < 2) return;
|
|
double lo = *std::min_element(hist.begin(), hist.end());
|
|
double hi = *std::max_element(hist.begin(), hist.end());
|
|
if (hi <= lo) hi = lo + 1e-9;
|
|
float w = mx.x - mn.x, h = mx.y - mn.y;
|
|
std::vector<ImVec2> pts(n);
|
|
for (int i = 0; i < n; i++) {
|
|
float t = (n > 1) ? (float)i / (float)(n - 1) : 0.0f;
|
|
pts[i] = ImVec2(mn.x + t * w, mx.y - (float)((hist[i] - lo) / (hi - lo)) * h);
|
|
}
|
|
dl->AddPolyline(pts.data(), n, col, ImDrawFlags_None, 1.2f);
|
|
}
|
|
|
|
// Sparkline with a soft fill under the line — for the card's dedicated bottom strip.
|
|
static void pfDrawSparklineFilled(ImDrawList* dl, ImVec2 mn, ImVec2 mx,
|
|
const std::vector<double>& hist, ImU32 lineCol)
|
|
{
|
|
int n = (int)hist.size();
|
|
if (n < 2) return;
|
|
double lo = *std::min_element(hist.begin(), hist.end());
|
|
double hi = *std::max_element(hist.begin(), hist.end());
|
|
if (hi <= lo) hi = lo + 1e-9;
|
|
float w = mx.x - mn.x, h = mx.y - mn.y;
|
|
std::vector<ImVec2> pts(n);
|
|
for (int i = 0; i < n; i++) {
|
|
float t = (n > 1) ? (float)i / (float)(n - 1) : 0.0f;
|
|
pts[i] = ImVec2(mn.x + t * w, mx.y - (float)((hist[i] - lo) / (hi - lo)) * h);
|
|
}
|
|
for (int i = 0; i < n; i++) dl->PathLineTo(pts[i]);
|
|
dl->PathLineTo(ImVec2(pts[n - 1].x, mx.y));
|
|
dl->PathLineTo(ImVec2(pts[0].x, mx.y));
|
|
dl->PathFillConcave(WithAlpha(lineCol, 28));
|
|
dl->AddPolyline(pts.data(), n, WithAlpha(lineCol, 220), ImDrawFlags_None, 1.4f);
|
|
}
|
|
|
|
// Dashboard-grid state for the portfolio cards (drag to move, corner-drag to resize).
|
|
struct PfCell { int col, row, w, h; };
|
|
static int s_pf_drag = -1; // card index being dragged (-1 = none)
|
|
static int s_pf_resize = -1; // card index being resized
|
|
static bool s_pf_moved = false; // drag passed the click threshold this gesture
|
|
static ImVec2 s_pf_press; // mouse pos at grab
|
|
static ImVec2 s_pf_grab; // mouse offset within the card at grab
|
|
static PfCell s_pf_old = {0,0,1,1};// dragged card's cell at grab (for swap-on-drop)
|
|
static PfCell s_pf_target = {0,0,1,1}; // live drop target cell
|
|
|
|
// Build the right-hand amount strings for a group card / preview from its price-data config.
|
|
struct PfDisplay {
|
|
std::string primary; // name-row, top-right (DRGX amount or the value)
|
|
std::string secondary; // below primary (the value, when DRGX is also shown)
|
|
std::string change; // "+2.34%" (live-market bases only) or empty
|
|
ImU32 changeCol = 0;
|
|
};
|
|
static PfDisplay pfBuildDisplay(const config::Settings::PortfolioEntry& e, double bal,
|
|
const MarketInfo& market)
|
|
{
|
|
PfDisplay d;
|
|
char b[80];
|
|
std::string valueStr; bool hasValue = false;
|
|
if (e.priceBasis == 0 && market.price_usd > 0) {
|
|
snprintf(b, sizeof(b), "$%.2f", bal * market.price_usd); valueStr = b; hasValue = true;
|
|
} else if (e.priceBasis == 1 && market.price_btc > 0) {
|
|
snprintf(b, sizeof(b), "%.8f BTC", bal * market.price_btc); valueStr = b; hasValue = true;
|
|
} else if (e.priceBasis == 3 && e.manualPrice > 0.0) {
|
|
snprintf(b, sizeof(b), "%.2f %s", bal * e.manualPrice, e.manualCurrency.c_str());
|
|
valueStr = b; hasValue = true;
|
|
}
|
|
std::string drgxStr;
|
|
if (e.showDrgx) { snprintf(b, sizeof(b), "%.4f %s", bal, DRAGONX_TICKER); drgxStr = b; }
|
|
if (e.showDrgx) {
|
|
d.primary = drgxStr;
|
|
if (e.showValue && hasValue) d.secondary = valueStr;
|
|
} else if (e.showValue && hasValue) {
|
|
d.primary = valueStr;
|
|
}
|
|
if (e.show24h && (e.priceBasis == 0 || e.priceBasis == 1) && market.change_24h != 0.0) {
|
|
snprintf(b, sizeof(b), "%+.2f%%", market.change_24h);
|
|
d.change = b;
|
|
d.changeCol = market.change_24h >= 0 ? material::Success() : material::Error();
|
|
}
|
|
return d;
|
|
}
|
|
|
|
// Preset accent palette for portfolio groups (0 slot = "default / no color").
|
|
static const ImU32 kPfPalette[] = {
|
|
IM_COL32(0x4F, 0x9D, 0xFF, 0xFF), // blue
|
|
IM_COL32(0x3D, 0xDC, 0x84, 0xFF), // green
|
|
IM_COL32(0xFF, 0xB0, 0x3D, 0xFF), // amber
|
|
IM_COL32(0xFF, 0x6B, 0x6B, 0xFF), // red
|
|
IM_COL32(0xB0, 0x7B, 0xFF, 0xFF), // purple
|
|
IM_COL32(0x4F, 0xD6, 0xD6, 0xFF), // teal
|
|
IM_COL32(0xFF, 0x8F, 0xC7, 0xFF), // pink
|
|
IM_COL32(0xC7, 0xCE, 0xD6, 0xFF), // slate
|
|
};
|
|
|
|
// Populate the working buffers for a new (index < 0) or existing entry.
|
|
static void PortfolioBeginEdit(App* app, int index)
|
|
{
|
|
const auto& entries = app->settings()->getPortfolioEntries();
|
|
s_pf_editing = index;
|
|
if (index >= 0 && index < (int)entries.size()) {
|
|
const auto& src = entries[index];
|
|
snprintf(s_pf_label, sizeof(s_pf_label), "%s", src.label.c_str());
|
|
s_pf_addrs = src.addresses;
|
|
s_pf_icon = src.icon;
|
|
s_pf_color = src.color;
|
|
s_pf_price_basis = src.priceBasis;
|
|
s_pf_manual_price = src.manualPrice;
|
|
snprintf(s_pf_manual_ccy, sizeof(s_pf_manual_ccy), "%s", src.manualCurrency.c_str());
|
|
s_pf_show_drgx = src.showDrgx;
|
|
s_pf_show_value = src.showValue;
|
|
s_pf_show_24h = src.show24h;
|
|
s_pf_show_sparkline = src.showSparkline;
|
|
s_pf_spark_interval = src.sparklineInterval;
|
|
} else {
|
|
s_pf_label[0] = '\0';
|
|
s_pf_addrs.clear();
|
|
s_pf_icon.clear();
|
|
s_pf_color = 0;
|
|
s_pf_price_basis = 0;
|
|
s_pf_manual_price = 0.0;
|
|
snprintf(s_pf_manual_ccy, sizeof(s_pf_manual_ccy), "USD");
|
|
s_pf_show_drgx = true;
|
|
s_pf_show_value = true;
|
|
s_pf_show_24h = false;
|
|
s_pf_show_sparkline = false;
|
|
s_pf_spark_interval = 0;
|
|
}
|
|
s_pf_search[0] = '\0';
|
|
s_pf_type_filter = 0;
|
|
s_pf_funded_only = false;
|
|
}
|
|
|
|
// The "Manage portfolio" modal: list/add/edit/delete entries, each a label tied to a group
|
|
// of wallet addresses. Persists to Settings on every mutation (like the address book).
|
|
static void RenderPortfolioEditor(App* app)
|
|
{
|
|
if (!s_portfolio_editor_open) return;
|
|
// Edit mode is a wider two-column layout; list mode stays compact.
|
|
float dialogW = std::min((s_pf_editing == -1 ? 560.0f : 780.0f),
|
|
ImGui::GetMainViewport()->Size.x * 0.92f);
|
|
if (!material::BeginOverlayDialog(TR("portfolio_manage_title"), &s_portfolio_editor_open, dialogW)) {
|
|
return;
|
|
}
|
|
|
|
config::Settings* settings = app->settings();
|
|
const auto& state = app->getWalletState();
|
|
|
|
auto persist = [&](const std::vector<config::Settings::PortfolioEntry>& entries) {
|
|
settings->setPortfolioEntries(entries);
|
|
settings->save();
|
|
};
|
|
|
|
if (s_pf_editing == -1) {
|
|
// ---- LIST MODE ----
|
|
const auto& entries = settings->getPortfolioEntries();
|
|
if (entries.empty()) {
|
|
Type().textColored(TypeStyle::Caption, OnSurfaceMedium(), TR("portfolio_no_entries"));
|
|
}
|
|
for (int i = 0; i < (int)entries.size(); i++) {
|
|
ImGui::PushID(i);
|
|
double bal = data::SumPortfolioBalance(entries[i].addresses, state.addresses);
|
|
char row[160];
|
|
snprintf(row, sizeof(row), "%s \xE2\x80\x94 %.4f %s (%d)",
|
|
entries[i].label.c_str(), bal, DRAGONX_TICKER, (int)entries[i].addresses.size());
|
|
ImGui::TextUnformatted(row);
|
|
ImGui::SameLine();
|
|
float bw = 72.0f;
|
|
float avail = ImGui::GetContentRegionAvail().x;
|
|
if (avail > bw * 2 + Layout::spacingSm())
|
|
ImGui::SetCursorPosX(ImGui::GetCursorPosX() + avail - bw * 2 - Layout::spacingSm());
|
|
if (ImGui::Button(TR("portfolio_edit"), ImVec2(bw, 0))) PortfolioBeginEdit(app, i);
|
|
ImGui::SameLine();
|
|
if (ImGui::Button(TR("portfolio_delete"), ImVec2(bw, 0))) {
|
|
auto e = entries; e.erase(e.begin() + i); persist(e);
|
|
ImGui::PopID();
|
|
break;
|
|
}
|
|
ImGui::PopID();
|
|
}
|
|
ImGui::Dummy(ImVec2(0, Layout::spacingSm()));
|
|
if (ImGui::Button(TR("portfolio_add_entry"))) PortfolioBeginEdit(app, -2);
|
|
} else {
|
|
// ---- EDIT MODE: two columns (Appearance | Addresses) ----
|
|
float dp = Layout::dpiScale();
|
|
ImFont* body2f = Type().body2();
|
|
ImFont* capF = Type().caption();
|
|
ImFont* sub1f = Type().subtitle1();
|
|
ImFont* iconFont = Type().iconSmall();
|
|
float iconFsz = iconFont->LegacySize;
|
|
|
|
float contentW = ImGui::GetContentRegionAvail().x;
|
|
float colGap = Layout::spacingLg();
|
|
float leftW = std::max(220.0f, (contentW - colGap) * 0.40f);
|
|
float rightW = contentW - colGap - leftW;
|
|
float colH = std::min(ImGui::GetMainViewport()->Size.y * 0.52f, 460.0f * dp);
|
|
|
|
// ===================== LEFT: APPEARANCE =====================
|
|
ImGui::BeginChild("##pfLeft", ImVec2(leftW, colH), false);
|
|
{
|
|
Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), TR("portfolio_appearance"));
|
|
ImGui::Dummy(ImVec2(0, Layout::spacingSm()));
|
|
|
|
// Live preview of the group card (icon + color + name + summed balance).
|
|
{
|
|
ImDrawList* pdl = ImGui::GetWindowDrawList();
|
|
float ppad = Layout::spacingMd();
|
|
float pw = ImGui::GetContentRegionAvail().x;
|
|
float ph = ppad * 2.0f + sub1f->LegacySize + Layout::spacingXs() + capF->LegacySize;
|
|
ImVec2 pMin = ImGui::GetCursorScreenPos();
|
|
ImVec2 pMax(pMin.x + pw, pMin.y + ph);
|
|
ImU32 accent = s_pf_color ? (ImU32)s_pf_color : 0;
|
|
GlassPanelSpec g; g.rounding = 10.0f; g.fillAlpha = 22; g.borderAlpha = 40;
|
|
DrawGlassPanel(pdl, pMin, pMax, g);
|
|
if (accent) {
|
|
float bx = pMin.x + 2.0f;
|
|
pdl->AddRectFilled(ImVec2(bx, pMin.y + ppad * 0.6f),
|
|
ImVec2(bx + 3.0f, pMax.y - ppad * 0.6f), accent, 2.0f);
|
|
}
|
|
if (s_pf_show_sparkline && (s_pf_price_basis == 0 || s_pf_price_basis == 1)) {
|
|
std::vector<double> h = pfResampleHistory(state.market.price_history, s_pf_spark_interval);
|
|
if (h.size() >= 2) {
|
|
ImU32 spCol = WithAlpha(h.back() >= h.front() ? Success() : Error(), 80);
|
|
ImVec2 spMin(pMin.x + ppad + (accent ? 6.0f : 0.0f), pMin.y + ph * 0.46f);
|
|
ImVec2 spMax(pMax.x - ppad, pMax.y - ppad * 0.6f);
|
|
pfDrawSparkline(pdl, spMin, spMax, h, spCol);
|
|
}
|
|
}
|
|
float rowY = pMin.y + ppad, nameX = pMin.x + ppad + (accent ? 6.0f : 0.0f);
|
|
if (!s_pf_icon.empty()) {
|
|
material::project_icons::drawByName(pdl, s_pf_icon,
|
|
ImVec2(nameX + sub1f->LegacySize * 0.5f, rowY + sub1f->LegacySize * 0.5f),
|
|
accent ? accent : OnSurface(), iconFont, sub1f->LegacySize);
|
|
nameX += sub1f->LegacySize + Layout::spacingSm();
|
|
}
|
|
const char* nm = s_pf_label[0] ? s_pf_label : TR("portfolio_group_name");
|
|
pdl->AddText(sub1f, sub1f->LegacySize, ImVec2(nameX, rowY),
|
|
s_pf_label[0] ? OnSurface() : OnSurfaceDisabled(), nm);
|
|
double pbal = data::SumPortfolioBalance(s_pf_addrs, state.addresses);
|
|
config::Settings::PortfolioEntry tmp;
|
|
tmp.priceBasis = s_pf_price_basis;
|
|
tmp.manualPrice = s_pf_manual_price;
|
|
tmp.manualCurrency = s_pf_manual_ccy;
|
|
tmp.showDrgx = s_pf_show_drgx;
|
|
tmp.showValue = s_pf_show_value;
|
|
tmp.show24h = s_pf_show_24h;
|
|
PfDisplay pd = pfBuildDisplay(tmp, pbal, state.market);
|
|
float primW = pd.primary.empty() ? 0.0f
|
|
: body2f->CalcTextSizeA(body2f->LegacySize, FLT_MAX, 0, pd.primary.c_str()).x;
|
|
if (!pd.primary.empty())
|
|
pdl->AddText(body2f, body2f->LegacySize,
|
|
ImVec2(pMax.x - ppad - primW, rowY + (sub1f->LegacySize - body2f->LegacySize) * 0.5f),
|
|
OnSurface(), pd.primary.c_str());
|
|
{
|
|
float belowY = rowY + sub1f->LegacySize + Layout::spacingXs();
|
|
float cursorR = pMax.x - ppad;
|
|
if (!pd.change.empty()) {
|
|
float cw = capF->CalcTextSizeA(capF->LegacySize, FLT_MAX, 0, pd.change.c_str()).x;
|
|
pdl->AddText(capF, capF->LegacySize, ImVec2(cursorR - cw, belowY), pd.changeCol, pd.change.c_str());
|
|
cursorR -= cw + Layout::spacingSm();
|
|
}
|
|
if (!pd.secondary.empty()) {
|
|
float sw2 = capF->CalcTextSizeA(capF->LegacySize, FLT_MAX, 0, pd.secondary.c_str()).x;
|
|
pdl->AddText(capF, capF->LegacySize, ImVec2(cursorR - sw2, belowY), OnSurfaceDisabled(), pd.secondary.c_str());
|
|
}
|
|
}
|
|
ImGui::Dummy(ImVec2(pw, ph));
|
|
}
|
|
ImGui::Dummy(ImVec2(0, Layout::spacingMd()));
|
|
|
|
// Label
|
|
ImGui::TextUnformatted(TR("portfolio_label"));
|
|
ImGui::SetNextItemWidth(-1);
|
|
ImGui::InputText("##pfLabel", s_pf_label, sizeof(s_pf_label));
|
|
ImGui::Dummy(ImVec2(0, Layout::spacingSm()));
|
|
|
|
// Color picker: preset swatches + a custom-color circle that opens a picker popup.
|
|
{
|
|
float sw = 22.0f * dp;
|
|
ImGui::TextUnformatted(TR("portfolio_color"));
|
|
ImDrawList* cdl = ImGui::GetWindowDrawList();
|
|
int nColors = (int)(sizeof(kPfPalette) / sizeof(kPfPalette[0]));
|
|
for (int c = 0; c <= nColors; c++) { // slot 0 = default / no color
|
|
if (c != 0) ImGui::SameLine(0, 5.0f * dp);
|
|
ImVec2 mn = ImGui::GetCursorScreenPos();
|
|
ImVec2 cc(mn.x + sw * 0.5f, mn.y + sw * 0.5f);
|
|
bool isDefault = (c == 0);
|
|
bool sel = isDefault ? (s_pf_color == 0u) : (s_pf_color == kPfPalette[c - 1]);
|
|
bool hov = ImGui::IsMouseHoveringRect(mn, ImVec2(mn.x + sw, mn.y + sw));
|
|
if (isDefault) cdl->AddCircle(cc, sw * 0.40f, OnSurfaceMedium(), 0, 1.5f * dp);
|
|
else cdl->AddCircleFilled(cc, sw * 0.40f, kPfPalette[c - 1]);
|
|
if (sel) cdl->AddCircle(cc, sw * 0.50f, OnSurface(), 0, 2.0f * dp);
|
|
else if (hov) cdl->AddCircle(cc, sw * 0.50f, WithAlpha(OnSurface(), 120), 0, 1.5f * dp);
|
|
ImGui::PushID(2000 + c);
|
|
ImGui::InvisibleButton("##pfcol", ImVec2(sw, sw));
|
|
if (ImGui::IsItemClicked()) s_pf_color = isDefault ? 0u : kPfPalette[c - 1];
|
|
ImGui::PopID();
|
|
}
|
|
|
|
// Custom-color circle: shows the current color when it isn't a preset, else a "+";
|
|
// click opens a color-picker popup.
|
|
bool isCustom = (s_pf_color != 0u);
|
|
for (int c = 0; c < nColors; c++)
|
|
if (s_pf_color == kPfPalette[c]) isCustom = false;
|
|
ImGui::SameLine(0, 5.0f * dp);
|
|
ImVec2 mn = ImGui::GetCursorScreenPos();
|
|
ImVec2 cc(mn.x + sw * 0.5f, mn.y + sw * 0.5f);
|
|
bool hov = ImGui::IsMouseHoveringRect(mn, ImVec2(mn.x + sw, mn.y + sw));
|
|
if (isCustom) {
|
|
cdl->AddCircleFilled(cc, sw * 0.40f, (ImU32)s_pf_color);
|
|
} else {
|
|
cdl->AddCircle(cc, sw * 0.40f, OnSurfaceMedium(), 0, 1.5f * dp);
|
|
float pr = sw * 0.18f;
|
|
cdl->AddLine(ImVec2(cc.x - pr, cc.y), ImVec2(cc.x + pr, cc.y), OnSurfaceMedium(), 1.5f * dp);
|
|
cdl->AddLine(ImVec2(cc.x, cc.y - pr), ImVec2(cc.x, cc.y + pr), OnSurfaceMedium(), 1.5f * dp);
|
|
}
|
|
if (isCustom) cdl->AddCircle(cc, sw * 0.50f, OnSurface(), 0, 2.0f * dp);
|
|
else if (hov) cdl->AddCircle(cc, sw * 0.50f, WithAlpha(OnSurface(), 120), 0, 1.5f * dp);
|
|
ImGui::InvisibleButton("##pfcustomcol", ImVec2(sw, sw));
|
|
if (ImGui::IsItemClicked()) {
|
|
ImU32 base = s_pf_color ? (ImU32)s_pf_color : IM_COL32(0x4F, 0x9D, 0xFF, 0xFF);
|
|
s_pf_custom_rgb[0] = ((base >> IM_COL32_R_SHIFT) & 0xFF) / 255.0f;
|
|
s_pf_custom_rgb[1] = ((base >> IM_COL32_G_SHIFT) & 0xFF) / 255.0f;
|
|
s_pf_custom_rgb[2] = ((base >> IM_COL32_B_SHIFT) & 0xFF) / 255.0f;
|
|
ImGui::OpenPopup("##pfCustomColor");
|
|
}
|
|
if (hov) material::Tooltip("%s", TR("portfolio_custom_color"));
|
|
if (ImGui::BeginPopup("##pfCustomColor")) {
|
|
ImGui::ColorPicker3("##pfpick", s_pf_custom_rgb,
|
|
ImGuiColorEditFlags_NoSidePreview | ImGuiColorEditFlags_NoAlpha | ImGuiColorEditFlags_NoLabel);
|
|
s_pf_color = IM_COL32((int)(s_pf_custom_rgb[0] * 255.0f + 0.5f),
|
|
(int)(s_pf_custom_rgb[1] * 255.0f + 0.5f),
|
|
(int)(s_pf_custom_rgb[2] * 255.0f + 0.5f), 255);
|
|
ImGui::EndPopup();
|
|
}
|
|
}
|
|
ImGui::Dummy(ImVec2(0, Layout::spacingSm()));
|
|
|
|
// Price data: how this group's value is priced + which fields the card shows.
|
|
{
|
|
ImGui::TextUnformatted(TR("portfolio_price"));
|
|
const char* basisItems[4] = { TR("portfolio_price_usd"), TR("portfolio_price_btc"),
|
|
TR("portfolio_price_drgx"), TR("portfolio_price_manual") };
|
|
ImGui::SetNextItemWidth(-1);
|
|
ImGui::Combo("##pfBasis", &s_pf_price_basis, basisItems, 4);
|
|
|
|
if (s_pf_price_basis == 3) { // Manual: price-per-DRGX + currency label
|
|
float half = (ImGui::GetContentRegionAvail().x - Layout::spacingSm()) * 0.62f;
|
|
ImGui::SetNextItemWidth(half);
|
|
ImGui::InputDouble("##pfManPrice", &s_pf_manual_price, 0.0, 0.0, "%.6f");
|
|
if (s_pf_manual_price < 0.0) s_pf_manual_price = 0.0;
|
|
ImGui::SameLine();
|
|
ImGui::SetNextItemWidth(-1);
|
|
ImGui::InputTextWithHint("##pfManCcy", TR("portfolio_currency"), s_pf_manual_ccy, sizeof(s_pf_manual_ccy));
|
|
}
|
|
|
|
// Field toggles (which price fields appear on the card).
|
|
ImGui::Checkbox(DRAGONX_TICKER "##pfShowDrgx", &s_pf_show_drgx);
|
|
ImGui::SameLine();
|
|
ImGui::BeginDisabled(s_pf_price_basis == 2); // DRGX-only -> no value field
|
|
ImGui::Checkbox(TR("portfolio_show_value"), &s_pf_show_value);
|
|
ImGui::EndDisabled();
|
|
ImGui::SameLine();
|
|
ImGui::BeginDisabled(!(s_pf_price_basis == 0 || s_pf_price_basis == 1)); // 24h: live-market only
|
|
ImGui::Checkbox(TR("portfolio_show_24h"), &s_pf_show_24h);
|
|
ImGui::EndDisabled();
|
|
// Sparkline on its own line (also live-market only) + its interval.
|
|
ImGui::BeginDisabled(!(s_pf_price_basis == 0 || s_pf_price_basis == 1));
|
|
ImGui::Checkbox(TR("portfolio_show_sparkline"), &s_pf_show_sparkline);
|
|
ImGui::SameLine();
|
|
ImGui::BeginDisabled(!s_pf_show_sparkline);
|
|
const char* spItems[5] = { TR("portfolio_spark_min"), TR("portfolio_spark_hour"),
|
|
TR("portfolio_spark_day"), TR("portfolio_spark_week"),
|
|
TR("portfolio_spark_month") };
|
|
ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x);
|
|
ImGui::Combo("##pfSparkInterval", &s_pf_spark_interval, spItems, 5);
|
|
ImGui::EndDisabled();
|
|
ImGui::EndDisabled();
|
|
}
|
|
ImGui::Dummy(ImVec2(0, Layout::spacingSm()));
|
|
|
|
// Icon picker — fills the remaining height of the left column.
|
|
{
|
|
float cell = 28.0f * dp, cellGap = 4.0f * dp;
|
|
ImGui::TextUnformatted(TR("portfolio_icon"));
|
|
float iconGridH = std::max(cell * 2.0f + cellGap, ImGui::GetContentRegionAvail().y);
|
|
ImGui::BeginChild("##pfIconGrid", ImVec2(0, iconGridH), true);
|
|
ImDrawList* gdl = ImGui::GetWindowDrawList();
|
|
float availW = ImGui::GetContentRegionAvail().x;
|
|
int cols = std::max(1, (int)((availW + cellGap) / (cell + cellGap)));
|
|
int total = material::project_icons::walletIconCount() + 1; // slot 0 = "None"
|
|
int gcol = 0;
|
|
for (int k = 0; k < total; k++) {
|
|
if (gcol != 0) ImGui::SameLine(0, cellGap);
|
|
ImVec2 mn = ImGui::GetCursorScreenPos();
|
|
ImVec2 mx(mn.x + cell, mn.y + cell);
|
|
ImVec2 cc(mn.x + cell * 0.5f, mn.y + cell * 0.5f);
|
|
bool hov = ImGui::IsMouseHoveringRect(mn, mx);
|
|
bool isNone = (k == 0);
|
|
const char* nm2 = isNone ? "" : material::project_icons::walletIconName(k - 1);
|
|
bool sel = isNone ? s_pf_icon.empty() : (s_pf_icon == nm2);
|
|
if (sel) {
|
|
gdl->AddRectFilled(mn, mx, WithAlpha(Primary(), 40), 6.0f * dp);
|
|
gdl->AddRect(mn, mx, WithAlpha(Primary(), 120), 6.0f * dp, 0, 1.5f * dp);
|
|
} else if (hov) {
|
|
gdl->AddRectFilled(mn, mx, IM_COL32(255, 255, 255, 20), 6.0f * dp);
|
|
}
|
|
ImU32 icol = sel ? Primary() : (hov ? OnSurface() : OnSurfaceMedium());
|
|
if (isNone) {
|
|
float r = cell * 0.26f;
|
|
gdl->AddCircle(cc, r, icol, 0, 1.5f * dp);
|
|
gdl->AddLine(ImVec2(cc.x - r * 0.7f, cc.y + r * 0.7f),
|
|
ImVec2(cc.x + r * 0.7f, cc.y - r * 0.7f), icol, 1.5f * dp);
|
|
} else {
|
|
material::project_icons::drawByName(gdl, nm2, cc, icol, iconFont, iconFsz);
|
|
}
|
|
ImGui::PushID(k);
|
|
ImGui::InvisibleButton("##pfic", ImVec2(cell, cell));
|
|
if (ImGui::IsItemClicked()) s_pf_icon = isNone ? std::string() : std::string(nm2);
|
|
if (hov) material::Tooltip("%s", isNone ? TR("portfolio_no_icon") : nm2);
|
|
ImGui::PopID();
|
|
gcol = (gcol + 1) % cols;
|
|
}
|
|
ImGui::EndChild();
|
|
}
|
|
}
|
|
ImGui::EndChild();
|
|
|
|
ImGui::SameLine(0, colGap);
|
|
|
|
// ===================== RIGHT: ADDRESSES =====================
|
|
ImGui::BeginChild("##pfRight", ImVec2(rightW, colH), false);
|
|
{
|
|
Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), TR("portfolio_addresses_hdr"));
|
|
ImGui::SameLine();
|
|
{
|
|
char selc[48];
|
|
snprintf(selc, sizeof(selc), TR("portfolio_addresses_sel"), (int)s_pf_addrs.size());
|
|
float w = capF->CalcTextSizeA(capF->LegacySize, FLT_MAX, 0, selc).x;
|
|
float ax = ImGui::GetContentRegionAvail().x;
|
|
if (ax > w) ImGui::SetCursorPosX(ImGui::GetCursorPosX() + ax - w);
|
|
Type().textColored(TypeStyle::Caption, OnSurfaceMedium(), selc);
|
|
}
|
|
ImGui::Dummy(ImVec2(0, Layout::spacingXs()));
|
|
|
|
// Search
|
|
ImGui::SetNextItemWidth(-1);
|
|
ImGui::InputTextWithHint("##pfSearch", TR("portfolio_search"), s_pf_search, sizeof(s_pf_search));
|
|
ImGui::Dummy(ImVec2(0, Layout::spacingXs()));
|
|
|
|
// Type filter chips + funded toggle
|
|
{
|
|
const char* flabels[3] = { TR("portfolio_select_all"), TR("shielded"), TR("transparent") };
|
|
for (int f = 0; f < 3; f++) {
|
|
if (f) ImGui::SameLine(0, 4.0f * dp);
|
|
bool active = (s_pf_type_filter == f);
|
|
if (active) ImGui::PushStyleColor(ImGuiCol_Button, ImGui::ColorConvertU32ToFloat4(WithAlpha(Primary(), 200)));
|
|
if (ImGui::SmallButton((std::string(flabels[f]) + "##ptf" + std::to_string(f)).c_str()))
|
|
s_pf_type_filter = f;
|
|
if (active) ImGui::PopStyleColor();
|
|
}
|
|
ImGui::SameLine(0, Layout::spacingMd());
|
|
ImGui::Checkbox(TR("portfolio_funded"), &s_pf_funded_only);
|
|
}
|
|
ImGui::Dummy(ImVec2(0, Layout::spacingXs()));
|
|
|
|
// Build the filtered address list (selected first, then by balance desc).
|
|
std::string search = s_pf_search;
|
|
std::vector<const AddressInfo*> filtered;
|
|
for (const auto& a : state.addresses) {
|
|
if (s_pf_type_filter == 1 && a.type != "shielded") continue;
|
|
if (s_pf_type_filter == 2 && a.type != "transparent") continue;
|
|
if (s_pf_funded_only && a.balance <= 1e-9) continue;
|
|
if (!search.empty()) {
|
|
std::string hay = a.address + " " + app->getAddressLabel(a.address);
|
|
if (!util::containsIgnoreCase(hay, search)) continue;
|
|
}
|
|
filtered.push_back(&a);
|
|
}
|
|
std::sort(filtered.begin(), filtered.end(), [&](const AddressInfo* x, const AddressInfo* y) {
|
|
bool sx = data::PortfolioEntryContains(s_pf_addrs, x->address);
|
|
bool sy = data::PortfolioEntryContains(s_pf_addrs, y->address);
|
|
if (sx != sy) return sx;
|
|
return x->balance > y->balance;
|
|
});
|
|
|
|
// Select-shown / clear
|
|
if (ImGui::SmallButton(TR("portfolio_select_shown")))
|
|
for (const AddressInfo* a : filtered) data::PortfolioEntryAdd(s_pf_addrs, a->address);
|
|
ImGui::SameLine();
|
|
if (ImGui::SmallButton(TR("portfolio_clear_sel"))) s_pf_addrs.clear();
|
|
ImGui::Dummy(ImVec2(0, Layout::spacingXs()));
|
|
|
|
// Address list fills the remaining height in the right column.
|
|
float listH = std::max(60.0f, ImGui::GetContentRegionAvail().y);
|
|
ImGui::BeginChild("##pfAddrList", ImVec2(0, listH), true);
|
|
ImDrawList* ldl = ImGui::GetWindowDrawList();
|
|
float rowH = std::max(26.0f * dp, body2f->LegacySize + Layout::spacingSm());
|
|
float lw = ImGui::GetContentRegionAvail().x;
|
|
if (filtered.empty())
|
|
Type().textColored(TypeStyle::Caption, OnSurfaceDisabled(), TR("portfolio_no_addr_match"));
|
|
for (const AddressInfo* ap : filtered) {
|
|
const AddressInfo& a = *ap;
|
|
bool inSet = data::PortfolioEntryContains(s_pf_addrs, a.address);
|
|
ImVec2 rmn = ImGui::GetCursorScreenPos();
|
|
ImVec2 rmx(rmn.x + lw, rmn.y + rowH);
|
|
bool rhov = ImGui::IsMouseHoveringRect(rmn, rmx);
|
|
if (inSet) ldl->AddRectFilled(rmn, rmx, WithAlpha(Primary(), 22), 4.0f);
|
|
else if (rhov) ldl->AddRectFilled(rmn, rmx, IM_COL32(255, 255, 255, 14), 4.0f);
|
|
float rcy = rmn.y + rowH * 0.5f;
|
|
float rx = rmn.x + Layout::spacingSm();
|
|
|
|
// Checkbox indicator
|
|
float cb = 15.0f * dp;
|
|
ImVec2 cbMin(rx, rcy - cb * 0.5f), cbMax(rx + cb, rcy + cb * 0.5f);
|
|
if (inSet) {
|
|
ldl->AddRectFilled(cbMin, cbMax, Primary(), 3.0f * dp);
|
|
ldl->AddLine(ImVec2(cbMin.x + cb * 0.22f, rcy),
|
|
ImVec2(cbMin.x + cb * 0.42f, cbMax.y - cb * 0.25f), IM_COL32(255, 255, 255, 255), 1.6f * dp);
|
|
ldl->AddLine(ImVec2(cbMin.x + cb * 0.42f, cbMax.y - cb * 0.25f),
|
|
ImVec2(cbMin.x + cb * 0.80f, cbMin.y + cb * 0.22f), IM_COL32(255, 255, 255, 255), 1.6f * dp);
|
|
} else {
|
|
ldl->AddRect(cbMin, cbMax, WithAlpha(OnSurface(), 120), 3.0f * dp, 0, 1.2f * dp);
|
|
}
|
|
rx += cb + Layout::spacingSm();
|
|
|
|
// Type chip (Z / T)
|
|
bool isZ = (a.type == "shielded");
|
|
const char* chip = isZ ? "Z" : "T";
|
|
ImU32 chipCol = isZ ? Success() : Warning();
|
|
float chipW = capF->CalcTextSizeA(capF->LegacySize, FLT_MAX, 0, chip).x + 8.0f * dp;
|
|
ldl->AddRectFilled(ImVec2(rx, rcy - capF->LegacySize * 0.5f - 2.0f),
|
|
ImVec2(rx + chipW, rcy + capF->LegacySize * 0.5f + 2.0f), WithAlpha(chipCol, 40), 4.0f * dp);
|
|
ldl->AddText(capF, capF->LegacySize, ImVec2(rx + 4.0f * dp, rcy - capF->LegacySize * 0.5f), chipCol, chip);
|
|
rx += chipW + Layout::spacingSm();
|
|
|
|
// Address's own icon (if set)
|
|
std::string aicon = app->getAddressIcon(a.address);
|
|
if (!aicon.empty()) {
|
|
material::project_icons::drawByName(ldl, aicon, ImVec2(rx + iconFsz * 0.5f, rcy), OnSurfaceMedium(), iconFont, iconFsz);
|
|
rx += iconFsz + Layout::spacingSm();
|
|
}
|
|
|
|
// Balance (right) then primary text (label or truncated address).
|
|
char balbuf[48];
|
|
snprintf(balbuf, sizeof(balbuf), "%.4f", a.balance);
|
|
float balW = capF->CalcTextSizeA(capF->LegacySize, FLT_MAX, 0, balbuf).x;
|
|
float textRight = rmx.x - Layout::spacingSm() - balW - Layout::spacingSm();
|
|
std::string alabel = app->getAddressLabel(a.address);
|
|
std::string primary = alabel.empty() ? util::truncateMiddle(a.address, 22) : alabel;
|
|
float availTextW = textRight - rx;
|
|
while (primary.size() > 1 &&
|
|
body2f->CalcTextSizeA(body2f->LegacySize, FLT_MAX, 0, primary.c_str()).x > availTextW)
|
|
primary.pop_back();
|
|
ldl->AddText(body2f, body2f->LegacySize, ImVec2(rx, rcy - body2f->LegacySize * 0.5f),
|
|
inSet ? OnSurface() : OnSurfaceMedium(), primary.c_str());
|
|
ldl->AddText(capF, capF->LegacySize, ImVec2(rmx.x - Layout::spacingSm() - balW, rcy - capF->LegacySize * 0.5f),
|
|
a.balance > 1e-9 ? OnSurface() : OnSurfaceDisabled(), balbuf);
|
|
|
|
// Whole row toggles selection.
|
|
ImGui::PushID(a.address.c_str());
|
|
ImGui::InvisibleButton("##pfrow", ImVec2(lw, rowH));
|
|
if (ImGui::IsItemClicked()) {
|
|
if (inSet) data::PortfolioEntryRemove(s_pf_addrs, a.address);
|
|
else data::PortfolioEntryAdd(s_pf_addrs, a.address);
|
|
}
|
|
ImGui::PopID();
|
|
}
|
|
ImGui::EndChild();
|
|
}
|
|
ImGui::EndChild();
|
|
|
|
// ===================== ACTIONS =====================
|
|
ImGui::Dummy(ImVec2(0, Layout::spacingSm()));
|
|
bool canSave = s_pf_label[0] != '\0';
|
|
ImGui::BeginDisabled(!canSave);
|
|
if (ImGui::Button(TR("portfolio_save"))) {
|
|
auto entries = settings->getPortfolioEntries();
|
|
// Start from the existing entry when editing so its grid placement/size (and any
|
|
// other fields not on this form) are preserved — editing must not reset the card.
|
|
config::Settings::PortfolioEntry e;
|
|
if (s_pf_editing >= 0 && s_pf_editing < (int)entries.size()) e = entries[s_pf_editing];
|
|
e.label = s_pf_label;
|
|
e.addresses = s_pf_addrs;
|
|
e.icon = s_pf_icon;
|
|
e.color = s_pf_color;
|
|
e.priceBasis = s_pf_price_basis;
|
|
e.manualPrice = s_pf_manual_price;
|
|
e.manualCurrency = s_pf_manual_ccy;
|
|
e.showDrgx = s_pf_show_drgx;
|
|
e.showValue = s_pf_show_value;
|
|
e.show24h = s_pf_show_24h;
|
|
e.showSparkline = s_pf_show_sparkline;
|
|
e.sparklineInterval = s_pf_spark_interval;
|
|
if (s_pf_editing >= 0 && s_pf_editing < (int)entries.size()) entries[s_pf_editing] = e;
|
|
else entries.push_back(e);
|
|
persist(entries);
|
|
s_pf_editing = -1;
|
|
}
|
|
ImGui::EndDisabled();
|
|
ImGui::SameLine();
|
|
if (ImGui::Button(TR("portfolio_cancel"))) s_pf_editing = -1;
|
|
}
|
|
|
|
material::EndOverlayDialog();
|
|
}
|
|
|
|
void RenderMarketTab(App* app)
|
|
{
|
|
auto& S = schema::UI();
|
|
auto summaryPanel = S.table("tabs.market", "summary-panel");
|
|
auto btcPriceLbl = S.label("tabs.market", "btc-price-label");
|
|
auto change24hLbl = S.label("tabs.market", "change-24h-label");
|
|
auto volumeLbl = S.label("tabs.market", "volume-label");
|
|
auto volumeValLbl = S.label("tabs.market", "volume-value-label");
|
|
auto mktCapLbl = S.label("tabs.market", "market-cap-label");
|
|
auto mktCapValLbl = S.label("tabs.market", "market-cap-value-label");
|
|
auto chartElem = S.drawElement("tabs.market", "chart");
|
|
auto portfolioValLbl = S.label("tabs.market", "portfolio-value-label");
|
|
auto portfolioBtcLbl = S.label("tabs.market", "portfolio-btc-label");
|
|
const auto& state = app->getWalletState();
|
|
const auto& market = state.market;
|
|
|
|
// Kick a once-per-session live exchange-list fetch (self-guarded), then source the
|
|
// registry from it (falling back to the compiled-in list until it arrives).
|
|
app->refreshExchanges();
|
|
const auto& registry = EffectiveRegistry(market);
|
|
|
|
// Load persisted exchange/pair on first frame
|
|
LoadMarketState(app->settings(), registry);
|
|
|
|
if (s_exchange_idx >= (int)registry.size()) s_exchange_idx = 0;
|
|
const auto& currentExchange = registry[s_exchange_idx];
|
|
if (s_pair_idx >= (int)currentExchange.pairs.size()) s_pair_idx = 0;
|
|
|
|
// Non-scrolling container — content resizes to fit available height
|
|
ImVec2 marketAvail = ImGui::GetContentRegionAvail();
|
|
// Scrollable: the portfolio grid can extend past the window and scroll into view.
|
|
ImGui::BeginChild("##MarketScroll", marketAvail, false, ImGuiWindowFlags_NoBackground);
|
|
|
|
// Responsive: scale factors per frame
|
|
float availWidth = ImGui::GetContentRegionAvail().x;
|
|
float hs = Layout::hScale(availWidth);
|
|
float vs = Layout::vScale(marketAvail.y);
|
|
float pad = Layout::cardInnerPadding();
|
|
float gap = Layout::cardGap();
|
|
|
|
ImDrawList* dl = ImGui::GetWindowDrawList();
|
|
GlassPanelSpec glassSpec;
|
|
glassSpec.rounding = Layout::glassRounding();
|
|
ImFont* ovFont = Type().overline();
|
|
ImFont* capFont = Type().caption();
|
|
ImFont* sub1 = Type().subtitle1();
|
|
ImFont* h4 = Type().h4();
|
|
ImFont* body2 = Type().body2();
|
|
|
|
char buf[128];
|
|
|
|
// ================================================================
|
|
// Section geometry.
|
|
// ================================================================
|
|
float mktDp = Layout::dpiScale();
|
|
|
|
// -- Compact price chart: a modest responsive height, no longer stretched to fill the tab. --
|
|
float chartH = std::max(110.0f * vs, std::min(chartElem.height * vs, marketAvail.y * 0.22f));
|
|
|
|
// -- Hero header: size to the ACTUAL content (price row + separator gap + stats row) so the
|
|
// chart starts right after "24H VOLUME"/"Market Cap" instead of below a reserved empty band. --
|
|
ImFont* mktH3 = Type().h3();
|
|
float heroHeaderH = Layout::spacingLg() // top pad
|
|
+ mktH3->LegacySize + Layout::spacingMd() // price row -> separator
|
|
+ Layout::spacingSm() // separator -> stats
|
|
+ ovFont->LegacySize + Layout::spacingXs() + sub1->LegacySize // stats label + value
|
|
+ Layout::spacingLg(); // bottom pad before the chart
|
|
|
|
// -- Portfolio geometry. No parent card background: the summary floats under the header
|
|
// and the custom-group cards float below it (each with its own glass background). --
|
|
const auto& pfEntriesGeo = app->settings()->getPortfolioEntries();
|
|
float ratioBarH = std::max(S.drawElement("tabs.market", "ratio-bar-min-height").size,
|
|
S.drawElement("tabs.market", "ratio-bar-height").size * vs);
|
|
float pfSummaryH = sub1->LegacySize + Layout::spacingSm() // fiat hero row
|
|
+ body2->LegacySize + Layout::spacingSm() // DRGX balance row
|
|
+ ratioBarH + Layout::spacingXs() + capFont->LegacySize // ratio bar + % label
|
|
+ Layout::spacingMd(); // gap before the group cards
|
|
int pfN = (int)pfEntriesGeo.size();
|
|
float pfCardPad = Layout::spacingMd(); // inner padding of each group card
|
|
// Fine SQUARE grid: cells are ~32px minimum and scale up to evenly fill the width. Cards snap to
|
|
// this grid and span many cells; they're drawn with an inner inset so adjacent cards don't touch.
|
|
float pfCardGap = 0.0f; // gapless cell grid
|
|
float pfInset = 3.0f * mktDp; // per-card inset for visual separation
|
|
const int pfMinW = 4, pfMinH = 3; // minimum card size in cells (~128x96)
|
|
int pfCols = std::max(pfMinW, (int)(availWidth / (32.0f * mktDp)));
|
|
float pfCellW = availWidth / (float)pfCols; // square cell edge (>= ~32px)
|
|
float pfCellH = pfCellW;
|
|
// Resolve each group's grid cell: honor a stored placement when it fits, else auto-place
|
|
// row-major into the first free cells. Deterministic each frame.
|
|
std::vector<PfCell> pfLayout((size_t)std::max(0, pfN));
|
|
{
|
|
std::vector<std::vector<char>> occ;
|
|
auto ensure = [&](int rEnd) { while ((int)occ.size() < rEnd) occ.emplace_back(pfCols, 0); };
|
|
auto fits = [&](int c, int r, int w, int h) -> bool {
|
|
if (c < 0 || r < 0 || c + w > pfCols) return false;
|
|
ensure(r + h);
|
|
for (int rr = r; rr < r + h; rr++) for (int cc = c; cc < c + w; cc++) if (occ[rr][cc]) return false;
|
|
return true;
|
|
};
|
|
auto mark = [&](int c, int r, int w, int h) { ensure(r + h);
|
|
for (int rr = r; rr < r + h; rr++) for (int cc = c; cc < c + w; cc++) occ[rr][cc] = 1; };
|
|
std::vector<char> placed((size_t)pfN, 0);
|
|
for (int i = 0; i < pfN; i++) {
|
|
const auto& e = pfEntriesGeo[i];
|
|
int w = std::max(pfMinW, std::min(e.gridW, pfCols)), h = std::max(pfMinH, e.gridH);
|
|
if (e.gridCol >= 0 && e.gridRow >= 0 && fits(e.gridCol, e.gridRow, w, h)) {
|
|
pfLayout[i] = {e.gridCol, e.gridRow, w, h}; mark(e.gridCol, e.gridRow, w, h); placed[i] = 1;
|
|
}
|
|
}
|
|
for (int i = 0; i < pfN; i++) {
|
|
if (placed[i]) continue;
|
|
const auto& e = pfEntriesGeo[i];
|
|
int w = std::max(pfMinW, std::min(e.gridW, pfCols)), h = std::max(pfMinH, e.gridH);
|
|
int fc = 0, fr = 0; bool found = false;
|
|
for (int r = 0; !found && r < 4096; r++)
|
|
for (int c = 0; c + w <= pfCols; c++)
|
|
if (fits(c, r, w, h)) { fc = c; fr = r; found = true; break; }
|
|
pfLayout[i] = {fc, fr, w, h}; mark(fc, fr, w, h);
|
|
}
|
|
}
|
|
int pfMaxRow = 0; for (const auto& L : pfLayout) pfMaxRow = std::max(pfMaxRow, L.row + L.h);
|
|
// Content height = the grid plus a couple of empty rows so cards can be dragged below the
|
|
// current bottom (the tab scrolls when the total exceeds the window).
|
|
float pfGroupsH = (pfN > 0) ? ((pfMaxRow + 2) * pfCellH) : 0.0f;
|
|
float portfolioH = pfSummaryH + pfGroupsH;
|
|
|
|
// ================================================================
|
|
// PRICE SUMMARY — Combined hero card with price, stats, and exchange
|
|
// ================================================================
|
|
{
|
|
float dp = Layout::dpiScale();
|
|
ImVec2 cardMin = ImGui::GetCursorScreenPos();
|
|
float cardH = heroHeaderH;
|
|
ImVec2 cardMax(cardMin.x + availWidth, cardMin.y + cardH);
|
|
// Combined hero + chart: draw ONE glass panel spanning the price/stats header AND the
|
|
// chart below it (chartH precomputed so the chart shrinks to fit the portfolio).
|
|
float mergedChartH = chartH;
|
|
ImVec2 mergedMax(cardMin.x + availWidth, cardMax.y + mergedChartH);
|
|
DrawGlassPanel(dl, cardMin, mergedMax, glassSpec);
|
|
|
|
float cx = cardMin.x + Layout::spacingLg();
|
|
float cy = cardMin.y + Layout::spacingLg();
|
|
|
|
if (market.price_usd > 0) {
|
|
// ---- HERO PRICE (large, prominent) ----
|
|
ImFont* h3 = Type().h3();
|
|
std::string priceStr = FormatPrice(market.price_usd);
|
|
ImU32 priceCol = Success();
|
|
DrawTextShadow(dl, h3, h3->LegacySize, ImVec2(cx, cy), priceCol, priceStr.c_str());
|
|
|
|
// Ticker label after price
|
|
float priceW = h3->CalcTextSizeA(h3->LegacySize, FLT_MAX, 0, priceStr.c_str()).x;
|
|
dl->AddText(body2, body2->LegacySize,
|
|
ImVec2(cx + priceW + Layout::spacingSm(), cy + (h3->LegacySize - body2->LegacySize)),
|
|
OnSurfaceMedium(), DRAGONX_TICKER);
|
|
|
|
// 24h change badge — to the right of ticker
|
|
float tickerW = body2->CalcTextSizeA(body2->LegacySize, FLT_MAX, 0, DRAGONX_TICKER).x;
|
|
float badgeX = cx + priceW + Layout::spacingSm() + tickerW + Layout::spacingMd();
|
|
ImU32 chgCol = market.change_24h >= 0 ? Success() : Error();
|
|
snprintf(buf, sizeof(buf), "%s%.2f%% 24h", market.change_24h >= 0 ? "+" : "", market.change_24h);
|
|
ImVec2 chgSz = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, 0, buf);
|
|
float badgePadH = Layout::spacingSm();
|
|
float badgePadV = Layout::spacingXs();
|
|
ImVec2 bMin(badgeX, cy + (h3->LegacySize - chgSz.y - badgePadV * 2) * 0.5f);
|
|
ImVec2 bMax(badgeX + chgSz.x + badgePadH * 2, bMin.y + chgSz.y + badgePadV * 2);
|
|
ImU32 badgeBg = market.change_24h >= 0 ? WithAlpha(Success(), 30) : WithAlpha(Error(), 30);
|
|
dl->AddRectFilled(bMin, bMax, badgeBg, 4.0f * dp);
|
|
dl->AddText(capFont, capFont->LegacySize, ImVec2(bMin.x + badgePadH, bMin.y + badgePadV), chgCol, buf);
|
|
|
|
// ---- SEPARATOR ----
|
|
float sepY = cy + h3->LegacySize + Layout::spacingMd();
|
|
float rnd = glassSpec.rounding;
|
|
dl->AddLine(ImVec2(cardMin.x + rnd * 0.5f, sepY),
|
|
ImVec2(cardMax.x - rnd * 0.5f, sepY),
|
|
WithAlpha(OnSurface(), 15), 1.0f * dp);
|
|
|
|
// ---- STATS ROW (24h Volume | Market Cap) ----
|
|
// (BTC-price column + the "updated Ns ago" staleness line were dropped to
|
|
// simplify; freshness is still shown by the attribution "Updated" line.)
|
|
float statsY = sepY + Layout::spacingSm();
|
|
float colW = (availWidth - Layout::spacingLg() * 2) / 2.0f;
|
|
|
|
struct StatItem { const char* label; std::string value; ImU32 valueCol; };
|
|
StatItem stats[2] = {
|
|
{TR("market_24h_volume"), FormatCompactUSD(market.volume_24h), OnSurface()},
|
|
{TR("market_cap"), FormatCompactUSD(market.market_cap), OnSurface()},
|
|
};
|
|
|
|
for (int i = 0; i < 2; i++) {
|
|
float sx = cardMin.x + Layout::spacingLg() + i * colW;
|
|
float centerX = sx + colW * 0.5f;
|
|
|
|
// Label (overline, centered)
|
|
ImVec2 lblSz = ovFont->CalcTextSizeA(ovFont->LegacySize, 10000, 0, stats[i].label);
|
|
dl->AddText(ovFont, ovFont->LegacySize,
|
|
ImVec2(centerX - lblSz.x * 0.5f, statsY), OnSurfaceMedium(), stats[i].label);
|
|
|
|
// Value (subtitle1, centered)
|
|
float valY = statsY + ovFont->LegacySize + Layout::spacingXs();
|
|
ImVec2 valSz = sub1->CalcTextSizeA(sub1->LegacySize, 10000, 0, stats[i].value.c_str());
|
|
dl->AddText(sub1, sub1->LegacySize,
|
|
ImVec2(centerX - valSz.x * 0.5f, valY), stats[i].valueCol, stats[i].value.c_str());
|
|
}
|
|
|
|
// ---- TRADE BUTTON (top-right of card) ----
|
|
if (!currentExchange.pairs.empty()) {
|
|
const char* pairName = currentExchange.pairs[s_pair_idx].displayName.c_str();
|
|
ImFont* iconFont = Type().iconSmall();
|
|
ImVec2 textSz = body2->CalcTextSizeA(body2->LegacySize, FLT_MAX, 0, pairName);
|
|
ImVec2 iconSz = iconFont->CalcTextSizeA(iconFont->LegacySize, FLT_MAX, 0, ICON_MD_OPEN_IN_NEW);
|
|
float iconGap = Layout::spacingSm();
|
|
float tradePadH = Layout::spacingMd();
|
|
float tradePadV = Layout::spacingSm();
|
|
float tradeBtnW = textSz.x + iconGap + iconSz.x + tradePadH * 2;
|
|
float tradeBtnH = std::max(textSz.y, iconSz.y) + tradePadV * 2;
|
|
float tradeBtnX = cardMax.x - pad - tradeBtnW;
|
|
float tradeBtnY = cardMin.y + Layout::spacingSm();
|
|
|
|
ImVec2 tMin(tradeBtnX, tradeBtnY), tMax(tradeBtnX + tradeBtnW, tradeBtnY + tradeBtnH);
|
|
bool tradeHov = material::IsRectHovered(tMin, tMax);
|
|
|
|
// Glass pill background
|
|
GlassPanelSpec tradeBtnGlass;
|
|
tradeBtnGlass.rounding = tradeBtnH * 0.5f;
|
|
tradeBtnGlass.fillAlpha = tradeHov ? 35 : 20;
|
|
DrawGlassPanel(dl, tMin, tMax, tradeBtnGlass);
|
|
if (tradeHov)
|
|
dl->AddRectFilled(tMin, tMax, WithAlpha(Primary(), 20), tradeBtnH * 0.5f);
|
|
|
|
// Text (pair name with body2, icon with icon font)
|
|
ImU32 tradeCol = tradeHov ? OnSurface() : OnSurfaceMedium();
|
|
float contentY = tradeBtnY + tradePadV;
|
|
float curX = tradeBtnX + tradePadH;
|
|
dl->AddText(body2, body2->LegacySize,
|
|
ImVec2(curX, contentY), tradeCol, pairName);
|
|
curX += textSz.x + iconGap;
|
|
dl->AddText(iconFont, iconFont->LegacySize,
|
|
ImVec2(curX, contentY + (textSz.y - iconSz.y) * 0.5f), tradeCol, ICON_MD_OPEN_IN_NEW);
|
|
|
|
// Click
|
|
ImVec2 savedCur = ImGui::GetCursorScreenPos();
|
|
ImGui::SetCursorScreenPos(tMin);
|
|
ImGui::InvisibleButton("##TradeOnExchange", ImVec2(tradeBtnW, tradeBtnH));
|
|
if (ImGui::IsItemClicked()) {
|
|
util::Platform::openUrl(currentExchange.pairs[s_pair_idx].tradeUrl);
|
|
}
|
|
if (ImGui::IsItemHovered()) {
|
|
ImGui::SetMouseCursor(ImGuiMouseCursor_Hand);
|
|
material::Tooltip(TR("market_trade_on"), currentExchange.name.c_str());
|
|
}
|
|
ImGui::SetCursorScreenPos(savedCur);
|
|
}
|
|
} else {
|
|
const char* status = market.price_loading ? TR("market_price_loading") : TR("market_price_unavailable");
|
|
DrawTextShadow(dl, sub1, sub1->LegacySize, ImVec2(cx, cy + 10), OnSurfaceDisabled(), status);
|
|
if (!market.price_loading && !market.price_error.empty()) {
|
|
std::string errorText = market.price_error;
|
|
float maxErrorW = cardMax.x - cx - Layout::spacingLg();
|
|
while (errorText.size() > 4 &&
|
|
capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, 0, errorText.c_str()).x > maxErrorW) {
|
|
errorText.pop_back();
|
|
}
|
|
if (errorText.size() < market.price_error.size()) errorText += "...";
|
|
dl->AddText(capFont, capFont->LegacySize,
|
|
ImVec2(cx, cy + 10 + sub1->LegacySize + Layout::spacingXs()),
|
|
Warning(), errorText.c_str());
|
|
}
|
|
}
|
|
|
|
// No inter-card gap — the chart is drawn immediately below, inside the same panel.
|
|
ImGui::SetCursorScreenPos(ImVec2(cardMin.x, cardMax.y));
|
|
ImGui::Dummy(ImVec2(availWidth, 0));
|
|
}
|
|
|
|
// ================================================================
|
|
// PRICE CHART — drawn inside the combined hero card's glass panel (above)
|
|
// ================================================================
|
|
{
|
|
// Plot the REAL accumulated price history (one point per refresh, oldest→newest).
|
|
// No synthetic data: until at least two real samples exist, the empty-state below
|
|
// ("not enough history yet") is shown rather than inventing a price curve.
|
|
s_price_history = market.price_history;
|
|
s_history_initialized = true;
|
|
|
|
// Chart height precomputed above (responsive — the chart absorbs the vertical slack
|
|
// left by the hero header + portfolio card). No glass panel here — it shares the
|
|
// combined hero+chart card's panel drawn in PRICE SUMMARY above.
|
|
ImVec2 chartMin = ImGui::GetCursorScreenPos();
|
|
ImVec2 chartMax(chartMin.x + availWidth, chartMin.y + chartH);
|
|
|
|
if (!s_price_history.empty() && s_price_history.size() >= 2) {
|
|
float chartPad = pad;
|
|
float labelPadLeft = std::max(S.drawElement("tabs.market", "chart-y-axis-min-padding").size, S.drawElement("tabs.market", "chart-y-axis-padding").size * hs);
|
|
float labelPadBottom = Layout::spacingXl();
|
|
|
|
float plotLeft = chartMin.x + labelPadLeft;
|
|
float plotRight = chartMax.x - chartPad;
|
|
float plotTop = chartMin.y + chartPad;
|
|
float plotBottom = chartMax.y - labelPadBottom;
|
|
float plotW = plotRight - plotLeft;
|
|
float plotH = plotBottom - plotTop;
|
|
|
|
// Compute Y range with padding
|
|
double yMin = *std::min_element(s_price_history.begin(), s_price_history.end());
|
|
double yMax = *std::max_element(s_price_history.begin(), s_price_history.end());
|
|
if (yMax <= yMin) { yMax = yMin + 1e-8; }
|
|
double yRange = yMax - yMin;
|
|
double yPadding = yRange * 0.12;
|
|
yMin -= yPadding;
|
|
yMax += yPadding;
|
|
|
|
// Horizontal grid lines (4 lines)
|
|
for (int g = 0; g <= 4; g++) {
|
|
float gy = plotTop + plotH * (float)g / 4.0f;
|
|
dl->AddLine(ImVec2(plotLeft, gy), ImVec2(plotRight, gy),
|
|
IM_COL32(255, 255, 255, 12), 1.0f);
|
|
double labelVal = yMax - (yMax - yMin) * (double)g / 4.0;
|
|
snprintf(buf, sizeof(buf), "$%.6f", labelVal);
|
|
ImVec2 labelSz = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, 0, buf);
|
|
dl->AddText(capFont, capFont->LegacySize,
|
|
ImVec2(plotLeft - labelSz.x - 6, gy - labelSz.y * 0.5f),
|
|
OnSurfaceDisabled(), buf);
|
|
}
|
|
|
|
// Build points
|
|
size_t n = s_price_history.size();
|
|
std::vector<ImVec2> points(n);
|
|
|
|
ImU32 lineCol = market.change_24h >= 0
|
|
? WithAlpha(Success(), 220) : WithAlpha(Error(), 220);
|
|
ImU32 fillCol = market.change_24h >= 0
|
|
? WithAlpha(Success(), 25) : WithAlpha(Error(), 25);
|
|
ImU32 dotCol = market.change_24h >= 0
|
|
? Success() : Error();
|
|
|
|
for (size_t i = 0; i < n; i++) {
|
|
float t = (n > 1) ? (float)i / (float)(n - 1) : 0.0f;
|
|
float x = plotLeft + t * plotW;
|
|
float y = plotBottom - (float)((s_price_history[i] - yMin) / (yMax - yMin)) * plotH;
|
|
points[i] = ImVec2(x, y);
|
|
}
|
|
|
|
// Fill under curve (single concave polygon to avoid AA seam artifacts)
|
|
if (n >= 2) {
|
|
for (size_t i = 0; i < n; i++)
|
|
dl->PathLineTo(points[i]);
|
|
dl->PathLineTo(ImVec2(points[n - 1].x, plotBottom));
|
|
dl->PathLineTo(ImVec2(points[0].x, plotBottom));
|
|
dl->PathFillConcave(fillCol);
|
|
}
|
|
|
|
// Line
|
|
dl->AddPolyline(points.data(), (int)points.size(), lineCol, ImDrawFlags_None, S.drawElement("tabs.market", "chart-line-thickness").size);
|
|
|
|
// Dots
|
|
float dotR = std::max(S.drawElement("tabs.market", "chart-dot-min-radius").size, S.drawElement("tabs.market", "chart-dot-radius").size * hs);
|
|
for (size_t i = 0; i < n; i++) {
|
|
dl->AddCircleFilled(points[i], dotR, dotCol);
|
|
}
|
|
|
|
// X-axis time labels. The price series is one sample per market refresh (~60s
|
|
// cadence, see RefreshScheduler::kPrice), so label the axis in approximate
|
|
// minutes-ago (rightmost = "now"). Approximate — a refresh can be delayed — hence "~".
|
|
{
|
|
const float kSecPerPoint = 60.0f; // RefreshScheduler::kPrice
|
|
int nPts = (int)n;
|
|
int ticks = std::min(4, nPts);
|
|
for (int tk = 0; tk < ticks; tk++) {
|
|
float t = (ticks > 1) ? (float)tk / (float)(ticks - 1) : 1.0f;
|
|
float xpos = plotLeft + t * plotW;
|
|
int idx = (int)(t * (nPts - 1) + 0.5f);
|
|
int minsAgo = (int)(((float)(nPts - 1 - idx) * kSecPerPoint) / 60.0f + 0.5f);
|
|
char tlbl[32];
|
|
if (minsAgo <= 0) snprintf(tlbl, sizeof(tlbl), "%s", TR("market_now"));
|
|
else if (minsAgo < 90) snprintf(tlbl, sizeof(tlbl), "~%dm", minsAgo);
|
|
else snprintf(tlbl, sizeof(tlbl), "~%.1fh", minsAgo / 60.0f);
|
|
ImVec2 lblSz = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, 0, tlbl);
|
|
float lx = (tk == 0) ? plotLeft
|
|
: (tk == ticks - 1) ? plotRight - lblSz.x
|
|
: xpos - lblSz.x * 0.5f;
|
|
dl->AddText(capFont, capFont->LegacySize,
|
|
ImVec2(lx, plotBottom + 2), OnSurfaceDisabled(), tlbl);
|
|
}
|
|
}
|
|
|
|
// Hover crosshair + tooltip
|
|
ImVec2 mousePos = ImGui::GetIO().MousePos;
|
|
if (mousePos.x >= plotLeft && mousePos.x <= plotRight &&
|
|
mousePos.y >= plotTop && mousePos.y <= plotBottom + labelPadBottom)
|
|
{
|
|
float mx = mousePos.x - plotLeft;
|
|
float closest_t = mx / plotW;
|
|
int idx = (int)(closest_t * (n - 1) + 0.5f);
|
|
if (idx < 0) idx = 0;
|
|
if (idx >= (int)n) idx = (int)n - 1;
|
|
|
|
float px = points[idx].x;
|
|
float py = points[idx].y;
|
|
|
|
dl->AddLine(ImVec2(px, plotTop), ImVec2(px, plotBottom),
|
|
IM_COL32(255, 255, 255, 40), 1.0f);
|
|
dl->AddLine(ImVec2(plotLeft, py), ImVec2(plotRight, py),
|
|
IM_COL32(255, 255, 255, 40), 1.0f);
|
|
|
|
float hoverDotR = std::max(S.drawElement("tabs.market", "chart-hover-dot-min-radius").size, S.drawElement("tabs.market", "chart-hover-dot-radius").size * hs);
|
|
float hoverRingR = std::max(S.drawElement("tabs.market", "chart-hover-ring-min-radius").size, S.drawElement("tabs.market", "chart-hover-ring-radius").size * hs);
|
|
dl->AddCircleFilled(ImVec2(px, py), hoverDotR, dotCol);
|
|
dl->AddCircle(ImVec2(px, py), hoverRingR, IM_COL32(255, 255, 255, 80), 0, 1.5f);
|
|
|
|
// Samples are per-refresh, not timestamped, so we don't claim a specific
|
|
// "Xh ago" — just show the price at the hovered point.
|
|
snprintf(buf, sizeof(buf), "%s", FormatPrice(s_price_history[idx]).c_str());
|
|
ImVec2 tipSz = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, 0, buf);
|
|
float tipPad = Layout::spacingSm() + Layout::spacingXs();
|
|
float tipX = px + 10;
|
|
float tipY = py - tipSz.y - tipPad * 2 - 4;
|
|
if (tipX + tipSz.x + tipPad * 2 > plotRight)
|
|
tipX = px - tipSz.x - tipPad * 2 - 10;
|
|
if (tipY < plotTop) tipY = py + 10;
|
|
|
|
ImVec2 tipMin(tipX, tipY);
|
|
ImVec2 tipMax(tipX + tipSz.x + tipPad * 2, tipY + tipSz.y + tipPad * 2);
|
|
dl->AddRectFilled(tipMin, tipMax, IM_COL32(20, 20, 30, 230), 4.0f);
|
|
dl->AddRect(tipMin, tipMax, IM_COL32(255, 255, 255, 30), 4.0f, 0, 1.0f);
|
|
dl->AddText(capFont, capFont->LegacySize,
|
|
ImVec2(tipX + tipPad, tipY + tipPad), dotCol, buf);
|
|
}
|
|
} else {
|
|
const char* msg = TR("market_no_history");
|
|
ImVec2 ts = sub1->CalcTextSizeA(sub1->LegacySize, FLT_MAX, 0, msg);
|
|
dl->AddText(sub1, sub1->LegacySize,
|
|
ImVec2(chartMin.x + (availWidth - ts.x) * 0.5f, chartMin.y + chartH * 0.45f),
|
|
OnSurfaceDisabled(), msg);
|
|
}
|
|
|
|
// --- Refresh button + timestamp pinned in chart top-right ---
|
|
{
|
|
float iconBtnSz = capFont->LegacySize + 8.0f;
|
|
float refreshX = chartMax.x - pad;
|
|
float refreshY = chartMin.y + pad * 0.5f;
|
|
|
|
// Draw refresh icon button
|
|
ImVec2 btnMin(refreshX - iconBtnSz, refreshY);
|
|
ImVec2 btnMax(refreshX, refreshY + iconBtnSz);
|
|
bool refreshHov = material::IsRectHovered(btnMin, btnMax);
|
|
if (refreshHov) {
|
|
dl->AddRectFilled(btnMin, btnMax, IM_COL32(255, 255, 255, 20), 4.0f);
|
|
ImGui::SetMouseCursor(ImGuiMouseCursor_Hand);
|
|
}
|
|
|
|
ImFont* iconSmall = material::Typography::instance().iconSmall();
|
|
ImVec2 iconSz = iconSmall->CalcTextSizeA(iconSmall->LegacySize, FLT_MAX, 0, ICON_MD_REFRESH);
|
|
dl->AddText(iconSmall, iconSmall->LegacySize,
|
|
ImVec2(btnMin.x + (iconBtnSz - iconSz.x) * 0.5f, btnMin.y + (iconBtnSz - iconSz.y) * 0.5f),
|
|
refreshHov ? OnSurface() : OnSurfaceMedium(), ICON_MD_REFRESH);
|
|
|
|
ImGui::SetCursorScreenPos(btnMin);
|
|
if (ImGui::InvisibleButton("##RefreshMarket", ImVec2(iconBtnSz, iconBtnSz))) {
|
|
app->refreshMarketData();
|
|
s_history_initialized = false;
|
|
s_last_refresh_time = ImGui::GetTime();
|
|
}
|
|
if (ImGui::IsItemHovered()) material::Tooltip("%s", TR("market_refresh_price"));
|
|
|
|
// Timestamp text to the left of refresh button
|
|
if (s_last_refresh_time > 0.0) {
|
|
double elapsed = ImGui::GetTime() - s_last_refresh_time;
|
|
if (elapsed < 60.0)
|
|
snprintf(buf, sizeof(buf), "%.0fs ago", elapsed);
|
|
else if (elapsed < 3600.0)
|
|
snprintf(buf, sizeof(buf), "%.0fm ago", elapsed / 60.0);
|
|
else
|
|
snprintf(buf, sizeof(buf), "%.1fh ago", elapsed / 3600.0);
|
|
ImVec2 tsSz = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, 0, buf);
|
|
dl->AddText(capFont, capFont->LegacySize,
|
|
ImVec2(btnMin.x - tsSz.x - 6, btnMin.y + (iconBtnSz - tsSz.y) * 0.5f),
|
|
OnSurfaceDisabled(), buf);
|
|
}
|
|
}
|
|
|
|
ImGui::SetCursorScreenPos(ImVec2(chartMin.x, chartMin.y + chartH));
|
|
ImGui::Dummy(ImVec2(availWidth, 0));
|
|
}
|
|
|
|
// ================================================================
|
|
// PAIR SELECTOR — every trading pair across all exchanges shown as
|
|
// round buttons (flat; no exchange dropdown). Wraps to multiple rows.
|
|
// ================================================================
|
|
ImGui::Dummy(ImVec2(0, S.drawElement("tabs.market", "exchange-top-gap").size));
|
|
{
|
|
float chipH = S.drawElement("tabs.market", "pair-chip-height").height;
|
|
float chipR = S.drawElement("tabs.market", "pair-chip-radius").radius;
|
|
float chipSpacing = S.drawElement("tabs.market", "pair-chip-spacing").size;
|
|
float innerGap = Layout::spacingSm();
|
|
float sidePad = Layout::spacingMd();
|
|
|
|
ImVec2 origin = ImGui::GetCursorScreenPos();
|
|
float left = origin.x;
|
|
float right = origin.x + availWidth;
|
|
float cx = left;
|
|
float cy = origin.y;
|
|
int btnCounter = 0;
|
|
|
|
for (int ex = 0; ex < (int)registry.size(); ex++) {
|
|
for (int pr = 0; pr < (int)registry[ex].pairs.size(); pr++) {
|
|
const std::string& pairName = registry[ex].pairs[pr].displayName;
|
|
const std::string& exName = registry[ex].name;
|
|
|
|
float pairW = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, 0, pairName.c_str()).x;
|
|
float exW = ovFont->CalcTextSizeA(ovFont->LegacySize, FLT_MAX, 0, exName.c_str()).x;
|
|
float cw = sidePad * 2.0f + pairW + innerGap + exW;
|
|
|
|
// Wrap to the next row when the pill would overflow (never on an empty row).
|
|
if (cx + cw > right && cx > left) {
|
|
cx = left;
|
|
cy += chipH + chipSpacing;
|
|
}
|
|
|
|
ImVec2 cMin(cx, cy);
|
|
ImVec2 cMax(cx + cw, cy + chipH);
|
|
bool selected = (ex == s_exchange_idx && pr == s_pair_idx);
|
|
bool hov = material::IsRectHovered(cMin, cMax);
|
|
ImU32 chipBg = selected ? WithAlpha(Primary(), 200)
|
|
: (hov ? WithAlpha(OnSurface(), 35) : WithAlpha(OnSurface(), 20));
|
|
ImU32 chipBorder = selected ? Primary() : WithAlpha(OnSurface(), 40);
|
|
ImU32 pairCol = selected ? IM_COL32(255, 255, 255, 255) : OnSurface();
|
|
ImU32 exCol = selected ? WithAlpha(IM_COL32(255, 255, 255, 255), 190) : OnSurfaceDisabled();
|
|
|
|
dl->AddRectFilled(cMin, cMax, chipBg, chipR);
|
|
dl->AddRect(cMin, cMax, chipBorder, chipR, 0, 1.0f);
|
|
|
|
float tx = cx + sidePad;
|
|
dl->AddText(capFont, capFont->LegacySize,
|
|
ImVec2(tx, cy + (chipH - capFont->LegacySize) * 0.5f), pairCol, pairName.c_str());
|
|
dl->AddText(ovFont, ovFont->LegacySize,
|
|
ImVec2(tx + pairW + innerGap, cy + (chipH - ovFont->LegacySize) * 0.5f),
|
|
exCol, exName.c_str());
|
|
|
|
ImGui::SetCursorScreenPos(cMin);
|
|
snprintf(buf, sizeof(buf), "##PairBtn%d", btnCounter++);
|
|
if (ImGui::InvisibleButton(buf, ImVec2(cw, chipH))) {
|
|
if (ex != s_exchange_idx || pr != s_pair_idx) {
|
|
s_exchange_idx = ex;
|
|
s_pair_idx = pr;
|
|
s_history_initialized = false;
|
|
app->settings()->setSelectedExchange(exName);
|
|
app->settings()->setSelectedPair(pairName);
|
|
app->settings()->save();
|
|
app->refreshMarketData();
|
|
}
|
|
}
|
|
if (ImGui::IsItemHovered()) ImGui::SetMouseCursor(ImGuiMouseCursor_Hand);
|
|
|
|
cx += cw + chipSpacing;
|
|
}
|
|
}
|
|
|
|
// Advance the cursor past the wrapped rows.
|
|
ImGui::SetCursorScreenPos(ImVec2(left, cy + chipH));
|
|
ImGui::Dummy(ImVec2(availWidth, 0));
|
|
|
|
// Attribution (moved here from the removed exchange-selector row).
|
|
ImGui::Dummy(ImVec2(0, Layout::spacingSm()));
|
|
Type().textColored(TypeStyle::Caption, OnSurfaceDisabled(), TR("market_attribution"));
|
|
if (!market.last_updated.empty()) {
|
|
ImGui::SameLine(0, 12);
|
|
snprintf(buf, sizeof(buf), " \xc2\xb7 Updated %s", market.last_updated.c_str());
|
|
Type().textColored(TypeStyle::Caption, OnSurfaceDisabled(), buf);
|
|
}
|
|
ImGui::Dummy(ImVec2(0, gap));
|
|
}
|
|
|
|
// ================================================================
|
|
// PORTFOLIO — floating summary (no card background) + custom-group cards
|
|
// ================================================================
|
|
{
|
|
Type().textColored(TypeStyle::Overline, OnSurfaceMedium(), TR("market_portfolio"));
|
|
// "Manage…" button, right-aligned on the header row — opens the portfolio editor.
|
|
{
|
|
const char* ml = TR("portfolio_manage");
|
|
float mBtnW = body2->CalcTextSizeA(body2->LegacySize, FLT_MAX, 0, ml).x + Layout::spacingMd() * 2;
|
|
ImGui::SameLine();
|
|
float availX = ImGui::GetContentRegionAvail().x;
|
|
if (availX > mBtnW) ImGui::SetCursorPosX(ImGui::GetCursorPosX() + availX - mBtnW);
|
|
if (ImGui::Button(ml, ImVec2(mBtnW, 0))) s_portfolio_editor_open = true;
|
|
}
|
|
ImGui::Dummy(ImVec2(0, Layout::spacingXs()));
|
|
|
|
double total_balance = state.totalBalance;
|
|
double private_balance = state.privateBalance;
|
|
double transparent_balance = state.transparentBalance;
|
|
|
|
// No parent card background — the summary floats directly under the "MY DRGX" header.
|
|
ImVec2 cardMin = ImGui::GetCursorScreenPos();
|
|
float rightEdge = cardMin.x + availWidth;
|
|
float cx = cardMin.x;
|
|
float cy = cardMin.y;
|
|
|
|
// ---- SUMMARY: fiat value (hero) + 24h change, BTC right-aligned ----
|
|
if (market.price_usd > 0) {
|
|
double portfolio_usd = total_balance * market.price_usd;
|
|
if (portfolio_usd >= 1.0) snprintf(buf, sizeof(buf), "$%.2f USD", portfolio_usd);
|
|
else snprintf(buf, sizeof(buf), "$%.6f USD", portfolio_usd);
|
|
DrawTextShadow(dl, sub1, sub1->LegacySize, ImVec2(cx, cy), Success(), buf);
|
|
float usdW = sub1->CalcTextSizeA(sub1->LegacySize, FLT_MAX, 0, buf).x;
|
|
|
|
if (market.change_24h != 0.0) {
|
|
char chg[48];
|
|
snprintf(chg, sizeof(chg), "%+.2f%% %s", market.change_24h, TR("market_24h_change"));
|
|
ImU32 chgCol = market.change_24h >= 0 ? Success() : Error();
|
|
dl->AddText(capFont, capFont->LegacySize,
|
|
ImVec2(cx + usdW + Layout::spacingMd(),
|
|
cy + (sub1->LegacySize - capFont->LegacySize)),
|
|
chgCol, chg);
|
|
}
|
|
|
|
double portfolio_btc = total_balance * market.price_btc;
|
|
snprintf(buf, sizeof(buf), "\xE2\x89\x88 %.8f BTC", portfolio_btc); // "≈ <n> BTC"
|
|
float btcW = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, 0, buf).x;
|
|
dl->AddText(capFont, capFont->LegacySize,
|
|
ImVec2(rightEdge - btcW, cy + (sub1->LegacySize - capFont->LegacySize)),
|
|
OnSurfaceMedium(), buf);
|
|
} else {
|
|
dl->AddText(sub1, sub1->LegacySize, ImVec2(cx, cy), OnSurfaceDisabled(), TR("market_no_price"));
|
|
}
|
|
cy += sub1->LegacySize + Layout::spacingSm();
|
|
|
|
// DRGX balance + Z/T breakdown (right-aligned).
|
|
snprintf(buf, sizeof(buf), "%.8f %s", total_balance, DRAGONX_TICKER);
|
|
dl->AddText(body2, body2->LegacySize, ImVec2(cx, cy), OnSurface(), buf);
|
|
snprintf(buf, sizeof(buf), "Z %.4f \xC2\xB7 T %.4f", private_balance, transparent_balance);
|
|
float brkW = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, 0, buf).x;
|
|
dl->AddText(capFont, capFont->LegacySize,
|
|
ImVec2(rightEdge - brkW, cy + 2), OnSurfaceDisabled(), buf);
|
|
cy += body2->LegacySize + Layout::spacingSm();
|
|
|
|
// Full-width shielded/transparent ratio bar + % label.
|
|
if (total_balance > 0) {
|
|
float barW = availWidth;
|
|
float shieldedRatio = (float)(private_balance / total_balance);
|
|
if (shieldedRatio > 1.0f) shieldedRatio = 1.0f;
|
|
if (shieldedRatio < 0.0f) shieldedRatio = 0.0f;
|
|
float shieldedW = barW * shieldedRatio;
|
|
float transpW = barW - shieldedW;
|
|
ImVec2 barStart(cx, cy);
|
|
|
|
dl->AddRectFilled(barStart, ImVec2(barStart.x + barW, barStart.y + ratioBarH),
|
|
IM_COL32(255, 255, 255, 10), 3.0f);
|
|
if (shieldedW > 0.5f)
|
|
dl->AddRectFilled(barStart, ImVec2(barStart.x + shieldedW, barStart.y + ratioBarH),
|
|
WithAlpha(Success(), 200),
|
|
transpW > 0.5f ? ImDrawFlags_RoundCornersLeft : ImDrawFlags_RoundCornersAll, 3.0f);
|
|
if (transpW > 0.5f)
|
|
dl->AddRectFilled(ImVec2(barStart.x + shieldedW, barStart.y),
|
|
ImVec2(barStart.x + barW, barStart.y + ratioBarH),
|
|
WithAlpha(Warning(), 200),
|
|
shieldedW > 0.5f ? ImDrawFlags_RoundCornersRight : ImDrawFlags_RoundCornersAll, 3.0f);
|
|
|
|
// market_pct_shielded is "%.0f%% Shielded" — pass a double (an int to %f is UB).
|
|
snprintf(buf, sizeof(buf), TR("market_pct_shielded"), static_cast<double>(shieldedRatio) * 100.0);
|
|
dl->AddText(capFont, capFont->LegacySize,
|
|
ImVec2(cx, cy + ratioBarH + Layout::spacingXs()), OnSurfaceDisabled(), buf);
|
|
}
|
|
|
|
// ---- CUSTOM GROUPS — dashboard grid: drag a card to move it, drag its corner to resize.
|
|
// A subtle dot grid shows while rearranging. Click (no drag) opens the editor. ----
|
|
if (pfN > 0) {
|
|
float gy = cardMin.y + pfSummaryH;
|
|
ImGuiIO& io = ImGui::GetIO();
|
|
bool interacting = (s_pf_drag >= 0 || s_pf_resize >= 0);
|
|
float rh = 14.0f * mktDp; // corner resize-grip size
|
|
|
|
auto cellMin = [&](const PfCell& L) {
|
|
return ImVec2(cx + L.col * (pfCellW + pfCardGap), gy + L.row * (pfCellH + pfCardGap));
|
|
};
|
|
auto cellSize = [&](int w, int h) {
|
|
return ImVec2(w * pfCellW + (w - 1) * pfCardGap, h * pfCellH + (h - 1) * pfCardGap);
|
|
};
|
|
|
|
// Draw one card's content into [gcMin, gcMax].
|
|
// Stat tile: header (icon + name, 24h badge) / hero value (large, centered band) /
|
|
// footer (DRGX amount) + a dedicated sparkline strip along the bottom.
|
|
auto drawCard = [&](ImVec2 gcMin, ImVec2 gcMax, const config::Settings::PortfolioEntry& e, bool hov) {
|
|
// The grid is gapless, so inset the card within its cell block for separation.
|
|
gcMin.x += pfInset; gcMin.y += pfInset; gcMax.x -= pfInset; gcMax.y -= pfInset;
|
|
double bal = data::SumPortfolioBalance(e.addresses, state.addresses);
|
|
ImU32 accent = e.color ? (ImU32)e.color : 0;
|
|
float pad = pfCardPad;
|
|
GlassPanelSpec gcGlass; gcGlass.rounding = 10.0f;
|
|
gcGlass.fillAlpha = hov ? 34 : 22; gcGlass.borderAlpha = 40;
|
|
DrawGlassPanel(dl, gcMin, gcMax, gcGlass);
|
|
if (hov) dl->AddRect(gcMin, gcMax, WithAlpha(OnSurface(), 70), 10.0f, 0, 1.0f);
|
|
if (accent)
|
|
dl->AddRectFilled(ImVec2(gcMin.x + 2.0f, gcMin.y + pad * 0.6f),
|
|
ImVec2(gcMin.x + 5.0f, gcMax.y - pad * 0.6f), accent, 2.0f);
|
|
|
|
float left = gcMin.x + pad + (accent ? 6.0f : 0.0f);
|
|
float right = gcMax.x - pad;
|
|
float availW = right - left;
|
|
auto fit = [&](std::string s, ImFont* f, float maxW) {
|
|
bool t = false;
|
|
while (s.size() > 1 && f->CalcTextSizeA(f->LegacySize, FLT_MAX, 0, s.c_str()).x > maxW) { s.pop_back(); t = true; }
|
|
if (t) s += "\xE2\x80\xA6";
|
|
return s;
|
|
};
|
|
|
|
// Value + DRGX strings per basis.
|
|
char vb[80]; std::string valueStr; bool hasValue = false;
|
|
if (e.priceBasis == 0 && market.price_usd > 0) { snprintf(vb, sizeof(vb), "$%.2f", bal * market.price_usd); valueStr = vb; hasValue = true; }
|
|
else if (e.priceBasis == 1 && market.price_btc > 0) { snprintf(vb, sizeof(vb), "%.6f BTC", bal * market.price_btc); valueStr = vb; hasValue = true; }
|
|
else if (e.priceBasis == 3 && e.manualPrice > 0.0) { snprintf(vb, sizeof(vb), "%.2f %s", bal * e.manualPrice, e.manualCurrency.c_str()); valueStr = vb; hasValue = true; }
|
|
char db[48]; snprintf(db, sizeof(db), "%.4f %s", bal, DRAGONX_TICKER);
|
|
bool heroIsValue = e.showValue && hasValue;
|
|
std::string heroStr = heroIsValue ? valueStr : (e.showDrgx ? std::string(db) : (hasValue ? valueStr : std::string(db)));
|
|
std::string footStr = (heroIsValue && e.showDrgx) ? std::string(db) : std::string();
|
|
|
|
// Header: icon + name (left), 24h badge (right).
|
|
float hy = gcMin.y + pad, nameX = left, nameMaxW = availW;
|
|
if (!e.icon.empty()) {
|
|
material::project_icons::drawByName(dl, e.icon.c_str(),
|
|
ImVec2(nameX + body2->LegacySize * 0.5f, hy + body2->LegacySize * 0.5f),
|
|
accent ? accent : OnSurfaceMedium(), Type().iconSmall(), body2->LegacySize);
|
|
nameX += body2->LegacySize + Layout::spacingSm();
|
|
nameMaxW = right - nameX;
|
|
}
|
|
if (e.show24h && (e.priceBasis == 0 || e.priceBasis == 1) && market.change_24h != 0.0) {
|
|
char cb[32]; snprintf(cb, sizeof(cb), "%+.2f%%", market.change_24h);
|
|
float cw = capFont->CalcTextSizeA(capFont->LegacySize, FLT_MAX, 0, cb).x;
|
|
dl->AddText(capFont, capFont->LegacySize,
|
|
ImVec2(right - cw, hy + (body2->LegacySize - capFont->LegacySize) * 0.5f),
|
|
market.change_24h >= 0 ? Success() : Error(), cb);
|
|
nameMaxW -= cw + Layout::spacingSm();
|
|
}
|
|
dl->AddText(body2, body2->LegacySize, ImVec2(nameX, hy), OnSurfaceMedium(),
|
|
fit(e.label, body2, nameMaxW).c_str());
|
|
|
|
// Sparkline strip along the bottom.
|
|
float sparkH = 0.0f;
|
|
if (e.showSparkline && (e.priceBasis == 0 || e.priceBasis == 1)) {
|
|
std::vector<double> hh = pfResampleHistory(market.price_history, e.sparklineInterval);
|
|
if (hh.size() >= 2) {
|
|
sparkH = std::max(18.0f * mktDp, (gcMax.y - gcMin.y) * 0.24f);
|
|
pfDrawSparklineFilled(dl, ImVec2(left, gcMax.y - pad - sparkH), ImVec2(right, gcMax.y - pad),
|
|
hh, hh.back() >= hh.front() ? Success() : Error());
|
|
}
|
|
}
|
|
|
|
// Footer: DRGX amount just above the sparkline.
|
|
float footBottom = gcMax.y - pad - (sparkH > 0 ? sparkH + Layout::spacingXs() : 0.0f);
|
|
float footTop = footBottom;
|
|
if (!footStr.empty()) {
|
|
footTop = footBottom - capFont->LegacySize;
|
|
dl->AddText(capFont, capFont->LegacySize, ImVec2(left, footTop),
|
|
OnSurfaceDisabled(), fit(footStr, capFont, availW).c_str());
|
|
}
|
|
|
|
// Hero value: large, centered in the band between the header and footer.
|
|
if (!heroStr.empty()) {
|
|
ImFont* heroFont = ((gcMax.y - gcMin.y) > 120.0f * mktDp) ? h4 : sub1;
|
|
float bandTop = hy + body2->LegacySize + Layout::spacingSm();
|
|
float bandBot = (footStr.empty() ? footBottom : footTop) - Layout::spacingXs();
|
|
float heroY = std::max(bandTop, (bandTop + bandBot) * 0.5f - heroFont->LegacySize * 0.5f);
|
|
dl->AddText(heroFont, heroFont->LegacySize, ImVec2(left, heroY),
|
|
OnSurface(), fit(heroStr, heroFont, availW).c_str());
|
|
}
|
|
};
|
|
|
|
// Subtle dot grid while rearranging (fine 32px cells; extends into the buffer rows).
|
|
if (interacting) {
|
|
ImU32 dotc = WithAlpha(OnSurface(), 38);
|
|
for (int r = 0; r <= pfMaxRow + 2; r++)
|
|
for (int c = 0; c <= pfCols; c++)
|
|
dl->AddCircleFilled(ImVec2(cx + c * pfCellW, gy + r * pfCellH), 1.2f * mktDp, dotc);
|
|
}
|
|
|
|
// Draw + hit-test each card. Skip the one being dragged/resized (drawn specially below).
|
|
for (int i = 0; i < pfN; i++) {
|
|
ImVec2 gcMin = cellMin(pfLayout[i]);
|
|
ImVec2 sz = cellSize(pfLayout[i].w, pfLayout[i].h);
|
|
ImVec2 gcMax(gcMin.x + sz.x, gcMin.y + sz.y);
|
|
|
|
if (i == s_pf_drag && s_pf_moved) {
|
|
dl->AddRect(gcMin, gcMax, WithAlpha(OnSurface(), 45), 10.0f, 0, 1.0f); // source ghost
|
|
continue;
|
|
}
|
|
if (i == s_pf_resize) continue;
|
|
|
|
bool hov = !interacting && material::IsRectHovered(gcMin, gcMax);
|
|
drawCard(gcMin, gcMax, pfEntriesGeo[i], hov);
|
|
|
|
// Resize grip (bottom-right).
|
|
bool gripHov = material::IsRectHovered(ImVec2(gcMax.x - rh, gcMax.y - rh), gcMax);
|
|
ImU32 gcc = WithAlpha(OnSurface(), gripHov ? 170 : 80);
|
|
for (int k = 1; k <= 2; k++) {
|
|
float o = k * 4.0f * mktDp;
|
|
dl->AddLine(ImVec2(gcMax.x - o, gcMax.y - 3.0f), ImVec2(gcMax.x - 3.0f, gcMax.y - o), gcc, 1.3f * mktDp);
|
|
}
|
|
|
|
// Start a gesture only when idle. One body button; the press location (corner vs body)
|
|
// decides resize vs move — avoids overlapping-item hit-test issues.
|
|
if (s_pf_drag < 0 && s_pf_resize < 0) {
|
|
ImGui::PushID(3000 + i);
|
|
ImGui::SetCursorScreenPos(gcMin);
|
|
ImGui::InvisibleButton("##pfBody", sz);
|
|
bool bodyAct = ImGui::IsItemActivated();
|
|
bool bodyHov = ImGui::IsItemHovered();
|
|
ImGui::PopID();
|
|
if (bodyHov) ImGui::SetMouseCursor(gripHov ? ImGuiMouseCursor_ResizeNWSE : ImGuiMouseCursor_Hand);
|
|
if (bodyAct) {
|
|
if (gripHov) { s_pf_resize = i; s_pf_old = pfLayout[i]; }
|
|
else {
|
|
s_pf_drag = i; s_pf_moved = false; s_pf_old = pfLayout[i];
|
|
s_pf_press = io.MousePos;
|
|
s_pf_grab = ImVec2(io.MousePos.x - gcMin.x, io.MousePos.y - gcMin.y);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
auto pfPersist = [&](const std::vector<config::Settings::PortfolioEntry>& v) {
|
|
app->settings()->setPortfolioEntries(v); app->settings()->save();
|
|
};
|
|
|
|
// ----- Resize in progress (corner drag) -----
|
|
if (s_pf_resize >= 0 && s_pf_resize < pfN) {
|
|
int i = s_pf_resize;
|
|
ImVec2 mn = cellMin(pfLayout[i]);
|
|
int nw = std::max(pfMinW, std::min(pfCols - pfLayout[i].col,
|
|
(int)((io.MousePos.x - mn.x + pfCardGap) / (pfCellW + pfCardGap) + 0.5f)));
|
|
int nh = std::max(pfMinH, (int)((io.MousePos.y - mn.y + pfCardGap) / (pfCellH + pfCardGap) + 0.5f));
|
|
ImVec2 sz = cellSize(nw, nh), mx(mn.x + sz.x, mn.y + sz.y);
|
|
drawCard(mn, mx, pfEntriesGeo[i], true);
|
|
dl->AddRect(mn, mx, WithAlpha(Primary(), 200), 10.0f, 0, 2.0f * mktDp);
|
|
ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeNWSE);
|
|
if (!io.MouseDown[0]) {
|
|
auto entries = app->settings()->getPortfolioEntries();
|
|
if (i < (int)entries.size()) {
|
|
entries[i].gridCol = pfLayout[i].col; entries[i].gridRow = pfLayout[i].row;
|
|
entries[i].gridW = nw; entries[i].gridH = nh;
|
|
pfPersist(entries);
|
|
}
|
|
s_pf_resize = -1;
|
|
}
|
|
}
|
|
|
|
// ----- Drag in progress -----
|
|
if (s_pf_drag >= 0 && s_pf_drag < pfN) {
|
|
int i = s_pf_drag;
|
|
if (io.MouseDown[0]) {
|
|
if (std::abs(io.MousePos.x - s_pf_press.x) > 4.0f || std::abs(io.MousePos.y - s_pf_press.y) > 4.0f)
|
|
s_pf_moved = true;
|
|
if (s_pf_moved) {
|
|
int w = pfLayout[i].w, h = pfLayout[i].h;
|
|
float tx = io.MousePos.x - s_pf_grab.x, ty = io.MousePos.y - s_pf_grab.y;
|
|
int tc = std::max(0, std::min(pfCols - w, (int)((tx - cx) / (pfCellW + pfCardGap) + 0.5f)));
|
|
int tr = std::max(0, (int)((ty - gy) / (pfCellH + pfCardGap) + 0.5f));
|
|
s_pf_target = {tc, tr, w, h};
|
|
ImVec2 tmn(cx + tc * (pfCellW + pfCardGap), gy + tr * (pfCellH + pfCardGap));
|
|
ImVec2 tsz = cellSize(w, h), tmx(tmn.x + tsz.x, tmn.y + tsz.y);
|
|
dl->AddRectFilled(tmn, tmx, WithAlpha(Primary(), 25), 10.0f);
|
|
dl->AddRect(tmn, tmx, WithAlpha(Primary(), 200), 10.0f, 0, 2.0f * mktDp);
|
|
ImVec2 fmn(tx, ty), fmx(fmn.x + tsz.x, fmn.y + tsz.y);
|
|
drawCard(fmn, fmx, pfEntriesGeo[i], true); // dragged card follows the mouse
|
|
ImGui::SetMouseCursor(ImGuiMouseCursor_ResizeAll);
|
|
}
|
|
} else {
|
|
if (!s_pf_moved) { PortfolioBeginEdit(app, i); s_portfolio_editor_open = true; }
|
|
else {
|
|
auto entries = app->settings()->getPortfolioEntries();
|
|
if (i < (int)entries.size()) {
|
|
int occ = -1;
|
|
for (int j = 0; j < pfN; j++)
|
|
if (j != i && pfLayout[j].col == s_pf_target.col && pfLayout[j].row == s_pf_target.row) { occ = j; break; }
|
|
entries[i].gridCol = s_pf_target.col; entries[i].gridRow = s_pf_target.row;
|
|
if (occ >= 0 && occ < (int)entries.size()) {
|
|
entries[occ].gridCol = s_pf_old.col; entries[occ].gridRow = s_pf_old.row;
|
|
}
|
|
pfPersist(entries);
|
|
}
|
|
}
|
|
s_pf_drag = -1; s_pf_moved = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
ImGui::SetCursorScreenPos(ImVec2(cardMin.x, cardMin.y + portfolioH));
|
|
ImGui::Dummy(ImVec2(availWidth, 0));
|
|
ImGui::Dummy(ImVec2(0, gap));
|
|
}
|
|
|
|
ImGui::EndChild(); // ##MarketScroll
|
|
|
|
// Portfolio editor modal (rendered outside the scroll child so it overlays the page).
|
|
RenderPortfolioEditor(app);
|
|
}
|
|
|
|
} // namespace ui
|
|
} // namespace dragonx
|