bitcoinunits.cpp raw
1 // Copyright (c) 2011-present The Bitcoin Core developers
2 // Distributed under the MIT software license, see the accompanying
3 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4
5 #include <qt/bitcoinunits.h>
6
7 #include <consensus/amount.h>
8
9 #include <QStringList>
10
11 #include <cassert>
12
13 static constexpr auto MAX_DIGITS_BTC = 16;
14
15 BitcoinUnits::BitcoinUnits(QObject *parent):
16 QAbstractListModel(parent),
17 unitlist(availableUnits())
18 {
19 }
20
21 QList<BitcoinUnit> BitcoinUnits::availableUnits()
22 {
23 QList<BitcoinUnit> unitlist;
24 unitlist.append(Unit::BTC);
25 unitlist.append(Unit::mBTC);
26 unitlist.append(Unit::uBTC);
27 unitlist.append(Unit::SAT);
28 return unitlist;
29 }
30
31 QString BitcoinUnits::longName(Unit unit)
32 {
33 switch (unit) {
34 case Unit::BTC: return QString("BTC");
35 case Unit::mBTC: return QString("mBTC");
36 case Unit::uBTC: return QString::fromUtf8("µBTC (bits)");
37 case Unit::SAT: return QString("Satoshi (sat)");
38 } // no default case, so the compiler can warn about missing cases
39 assert(false);
40 }
41
42 QString BitcoinUnits::shortName(Unit unit)
43 {
44 switch (unit) {
45 case Unit::BTC: return longName(unit);
46 case Unit::mBTC: return longName(unit);
47 case Unit::uBTC: return QString("bits");
48 case Unit::SAT: return QString("sat");
49 } // no default case, so the compiler can warn about missing cases
50 assert(false);
51 }
52
53 QString BitcoinUnits::description(Unit unit)
54 {
55 switch (unit) {
56 case Unit::BTC: return QString("Bitcoins");
57 case Unit::mBTC: return QString("Milli-Bitcoins (1 / 1" THIN_SP_UTF8 "000)");
58 case Unit::uBTC: return QString("Micro-Bitcoins (bits) (1 / 1" THIN_SP_UTF8 "000" THIN_SP_UTF8 "000)");
59 case Unit::SAT: return QString("Satoshi (sat) (1 / 100" THIN_SP_UTF8 "000" THIN_SP_UTF8 "000)");
60 } // no default case, so the compiler can warn about missing cases
61 assert(false);
62 }
63
64 qint64 BitcoinUnits::factor(Unit unit)
65 {
66 switch (unit) {
67 case Unit::BTC: return 100'000'000;
68 case Unit::mBTC: return 100'000;
69 case Unit::uBTC: return 100;
70 case Unit::SAT: return 1;
71 } // no default case, so the compiler can warn about missing cases
72 assert(false);
73 }
74
75 int BitcoinUnits::decimals(Unit unit)
76 {
77 switch (unit) {
78 case Unit::BTC: return 8;
79 case Unit::mBTC: return 5;
80 case Unit::uBTC: return 2;
81 case Unit::SAT: return 0;
82 } // no default case, so the compiler can warn about missing cases
83 assert(false);
84 }
85
86 QString BitcoinUnits::format(Unit unit, const CAmount& nIn, bool fPlus, SeparatorStyle separators, bool justify)
87 {
88 // Note: not using straight sprintf here because we do NOT want
89 // localized number formatting.
90 qint64 n = (qint64)nIn;
91 qint64 coin = factor(unit);
92 int num_decimals = decimals(unit);
93 qint64 n_abs = (n > 0 ? n : -n);
94 qint64 quotient = n_abs / coin;
95 QString quotient_str = QString::number(quotient);
96 if (justify) {
97 quotient_str = quotient_str.rightJustified(MAX_DIGITS_BTC - num_decimals, ' ');
98 }
99
100 // Use SI-style thin space separators as these are locale independent and can't be
101 // confused with the decimal marker.
102 QChar thin_sp(THIN_SP_CP);
103 int q_size = quotient_str.size();
104 if (separators == SeparatorStyle::ALWAYS || (separators == SeparatorStyle::STANDARD && q_size > 4))
105 for (int i = 3; i < q_size; i += 3)
106 quotient_str.insert(q_size - i, thin_sp);
107
108 if (n < 0)
109 quotient_str.insert(0, '-');
110 else if (fPlus && n > 0)
111 quotient_str.insert(0, '+');
112
113 if (num_decimals > 0) {
114 qint64 remainder = n_abs % coin;
115 QString remainder_str = QString::number(remainder).rightJustified(num_decimals, '0');
116 return quotient_str + QString(".") + remainder_str;
117 } else {
118 return quotient_str;
119 }
120 }
121
122
123 // NOTE: Using formatWithUnit in an HTML context risks wrapping
124 // quantities at the thousands separator. More subtly, it also results
125 // in a standard space rather than a thin space, due to a bug in Qt's
126 // XML whitespace canonicalisation
127 //
128 // Please take care to use formatHtmlWithUnit instead, when
129 // appropriate.
130
131 QString BitcoinUnits::formatWithUnit(Unit unit, const CAmount& amount, bool plussign, SeparatorStyle separators)
132 {
133 return format(unit, amount, plussign, separators) + QString(" ") + shortName(unit);
134 }
135
136 QString BitcoinUnits::formatHtmlWithUnit(Unit unit, const CAmount& amount, bool plussign, SeparatorStyle separators)
137 {
138 QString str(formatWithUnit(unit, amount, plussign, separators));
139 str.replace(QChar(THIN_SP_CP), QString(THIN_SP_HTML));
140 return QString("<span style='white-space: nowrap;'>%1</span>").arg(str);
141 }
142
143 QString BitcoinUnits::formatWithPrivacy(Unit unit, const CAmount& amount, SeparatorStyle separators, bool privacy)
144 {
145 assert(amount >= 0);
146 QString value;
147 if (privacy) {
148 value = format(unit, 0, false, separators, true).replace('0', '#');
149 } else {
150 value = format(unit, amount, false, separators, true);
151 }
152 return value + QString(" ") + shortName(unit);
153 }
154
155 bool BitcoinUnits::parse(Unit unit, const QString& value, CAmount* val_out)
156 {
157 if (value.isEmpty()) {
158 return false; // Refuse to parse invalid unit or empty string
159 }
160 int num_decimals = decimals(unit);
161
162 // Ignore spaces and thin spaces when parsing
163 QStringList parts = removeSpaces(value).split(".");
164
165 if(parts.size() > 2)
166 {
167 return false; // More than one dot
168 }
169 const QString& whole = parts[0];
170 QString decimals;
171
172 if(parts.size() > 1)
173 {
174 decimals = parts[1];
175 }
176 if(decimals.size() > num_decimals)
177 {
178 return false; // Exceeds max precision
179 }
180 bool ok = false;
181 QString str = whole + decimals.leftJustified(num_decimals, '0');
182
183 if(str.size() > 18)
184 {
185 return false; // Longer numbers will exceed 63 bits
186 }
187 CAmount retvalue(str.toLongLong(&ok));
188 if(val_out)
189 {
190 *val_out = retvalue;
191 }
192 return ok;
193 }
194
195 QString BitcoinUnits::getAmountColumnTitle(Unit unit)
196 {
197 return QObject::tr("Amount") + " (" + shortName(unit) + ")";
198 }
199
200 int BitcoinUnits::rowCount(const QModelIndex &parent) const
201 {
202 Q_UNUSED(parent);
203 return unitlist.size();
204 }
205
206 QVariant BitcoinUnits::data(const QModelIndex &index, int role) const
207 {
208 int row = index.row();
209 if(row >= 0 && row < unitlist.size())
210 {
211 Unit unit = unitlist.at(row);
212 switch(role)
213 {
214 case Qt::EditRole:
215 case Qt::DisplayRole:
216 return QVariant(longName(unit));
217 case Qt::ToolTipRole:
218 return QVariant(description(unit));
219 case UnitRole:
220 return QVariant::fromValue(unit);
221 }
222 }
223 return QVariant();
224 }
225
226 CAmount BitcoinUnits::maxMoney()
227 {
228 return MAX_MONEY;
229 }
230
231 namespace {
232 qint8 ToQint8(BitcoinUnit unit)
233 {
234 switch (unit) {
235 case BitcoinUnit::BTC: return 0;
236 case BitcoinUnit::mBTC: return 1;
237 case BitcoinUnit::uBTC: return 2;
238 case BitcoinUnit::SAT: return 3;
239 } // no default case, so the compiler can warn about missing cases
240 assert(false);
241 }
242
243 BitcoinUnit FromQint8(qint8 num)
244 {
245 switch (num) {
246 case 0: return BitcoinUnit::BTC;
247 case 1: return BitcoinUnit::mBTC;
248 case 2: return BitcoinUnit::uBTC;
249 case 3: return BitcoinUnit::SAT;
250 }
251 assert(false);
252 }
253 } // namespace
254
255 QDataStream& operator<<(QDataStream& out, const BitcoinUnit& unit)
256 {
257 return out << ToQint8(unit);
258 }
259
260 QDataStream& operator>>(QDataStream& in, BitcoinUnit& unit)
261 {
262 qint8 input;
263 in >> input;
264 unit = FromQint8(input);
265 return in;
266 }
267