mirror of
https://github.com/Such-Software/hash-wallet.git
synced 2026-10-26 06:08:40 +01:00
578 lines
22 KiB
Dart
578 lines
22 KiB
Dart
import 'package:cw_core/balance_card_style_settings.dart';
|
|
import 'package:cw_core/crypto_currency.dart';
|
|
import 'package:cw_core/utils/print_verbose.dart';
|
|
import 'package:flutter/material.dart';
|
|
|
|
enum CardDesignBackgroundTypes { image, svgIcon, svgFull, gradientOnly }
|
|
|
|
class CardColorCombination {
|
|
final Color textColor;
|
|
final Color textColorSecondary;
|
|
final Color backgroundImageColor;
|
|
|
|
const CardColorCombination(
|
|
{required this.textColor,
|
|
required this.textColorSecondary,
|
|
required this.backgroundImageColor});
|
|
|
|
static const light = CardColorCombination(
|
|
textColor: Color.fromARGB(200, 255, 255, 255),
|
|
textColorSecondary: Colors.white54,
|
|
backgroundImageColor: Color.fromARGB(200, 0, 0, 0));
|
|
|
|
static const dark = CardColorCombination(
|
|
textColor: Color.fromARGB(200, 0, 0, 0),
|
|
textColorSecondary: Colors.black45,
|
|
backgroundImageColor: Color.fromARGB(200, 255, 255, 255),
|
|
);
|
|
|
|
static const black = CardColorCombination(
|
|
textColor: Color.fromARGB(200, 255, 255, 255),
|
|
textColorSecondary: Colors.white54,
|
|
backgroundImageColor: Color.fromARGB(200, 255, 255, 255),
|
|
);
|
|
}
|
|
|
|
class CardIconPath {
|
|
final String path;
|
|
final bool preColored;
|
|
|
|
const CardIconPath(this.path, {this.preColored = false});
|
|
}
|
|
|
|
class CardDesign {
|
|
final Gradient gradient;
|
|
final String imagePath;
|
|
final CardDesignBackgroundTypes backgroundType;
|
|
final CardColorCombination colors;
|
|
final bool preColoredIcon;
|
|
|
|
const CardDesign(
|
|
{this.backgroundType = CardDesignBackgroundTypes.svgIcon,
|
|
this.gradient = const LinearGradient(
|
|
colors: [Colors.black], begin: Alignment.topCenter, end: Alignment.bottomCenter),
|
|
this.imagePath = "assets/new-ui/blank.svg",
|
|
this.colors = CardColorCombination.dark,
|
|
this.preColoredIcon = false});
|
|
|
|
static const LinearGradient gradientOrange = LinearGradient(
|
|
colors: <Color>[Color(0xFFFF7C02), Color(0xFFFF5602)],
|
|
begin: Alignment.topCenter,
|
|
end: Alignment.bottomCenter,
|
|
);
|
|
|
|
static const LinearGradient gradientYellow = LinearGradient(
|
|
colors: <Color>[Color(0xFFFFD000), Color(0xFFFFAA00)],
|
|
begin: Alignment.topCenter,
|
|
end: Alignment.bottomCenter,
|
|
);
|
|
static const LinearGradient gradientGreen = LinearGradient(
|
|
colors: <Color>[Color(0xFF5AA438), Color(0xFF5AA438)],
|
|
begin: Alignment.topCenter,
|
|
end: Alignment.bottomCenter,
|
|
);
|
|
|
|
static const LinearGradient gradientBlue = LinearGradient(
|
|
colors: <Color>[Color(0xFF4EBEFF), Color(0xFF1D78FF)],
|
|
begin: Alignment.topCenter,
|
|
end: Alignment.bottomCenter,
|
|
);
|
|
|
|
static const LinearGradient gradientPurple = LinearGradient(
|
|
colors: <Color>[Color(0xFF9E30FF), Color(0xFF7100BD)],
|
|
begin: Alignment.topCenter,
|
|
end: Alignment.bottomCenter,
|
|
);
|
|
|
|
static const LinearGradient gradientPink = LinearGradient(
|
|
colors: <Color>[Color(0xFFFF6CD3), Color(0xFFF200A9)],
|
|
begin: Alignment.topCenter,
|
|
end: Alignment.bottomCenter,
|
|
);
|
|
|
|
static const LinearGradient gradientRed = LinearGradient(
|
|
colors: <Color>[Color(0xFFFF2222), Color(0xFFA10000)],
|
|
begin: Alignment.topCenter,
|
|
end: Alignment.bottomCenter,
|
|
);
|
|
|
|
static const LinearGradient gradientSilver = LinearGradient(
|
|
colors: <Color>[Color(0xFFE0E8FF), Color(0xFF6D8ADE)],
|
|
begin: Alignment.topCenter,
|
|
end: Alignment.bottomCenter,
|
|
);
|
|
|
|
static const LinearGradient gradientGold = LinearGradient(
|
|
colors: <Color>[Color(0xFFE9CA74), Color(0xFF886A14)],
|
|
begin: Alignment.topCenter,
|
|
end: Alignment.bottomCenter,
|
|
);
|
|
|
|
static const LinearGradient gradientBlack = LinearGradient(
|
|
colors: <Color>[Color(0xFF2A2A2A), Color(0xFF000000)],
|
|
begin: Alignment.topCenter,
|
|
end: Alignment.bottomCenter,
|
|
);
|
|
|
|
static const List<Gradient> allGradients = <Gradient>[
|
|
gradientOrange,
|
|
gradientYellow,
|
|
gradientGreen,
|
|
gradientBlue,
|
|
gradientPurple,
|
|
gradientPink,
|
|
gradientRed,
|
|
gradientSilver,
|
|
gradientGold,
|
|
gradientBlack,
|
|
];
|
|
|
|
static const genericDefault = CardDesign(gradient: gradientBlue);
|
|
|
|
static const gradientOnlyDesign =
|
|
CardDesign(backgroundType: CardDesignBackgroundTypes.gradientOnly, gradient: gradientBlue);
|
|
|
|
static const btc = CardDesign(imagePath: "assets/new-ui/balance_card_icons/bitcoin.svg");
|
|
|
|
static const eth = CardDesign(imagePath: "assets/new-ui/balance_card_icons/ethereum.svg");
|
|
|
|
static const btcln = CardDesign(imagePath: "assets/new-ui/balance_card_icons/lightning.svg");
|
|
|
|
static const xmr = CardDesign(imagePath: "assets/new-ui/balance_card_icons/monero.svg");
|
|
|
|
static const ltc = CardDesign(imagePath: "assets/new-ui/balance_card_icons/litecoin.svg");
|
|
|
|
static const bch = CardDesign(imagePath: "assets/new-ui/balance_card_icons/bitcoin_cash.svg");
|
|
|
|
static const doge = CardDesign(imagePath: "assets/new-ui/balance_card_icons/dogecoin.svg");
|
|
|
|
static const base = CardDesign(imagePath: "assets/new-ui/balance_card_icons/base.svg");
|
|
|
|
static const pol = CardDesign(imagePath: "assets/new-ui/balance_card_icons/polygon.svg");
|
|
|
|
static const sol = CardDesign(imagePath: "assets/new-ui/balance_card_icons/solana.svg");
|
|
|
|
static const tron = CardDesign(imagePath: "assets/new-ui/balance_card_icons/tron.svg");
|
|
|
|
static const nano = CardDesign(imagePath: "assets/new-ui/balance_card_icons/nano.svg");
|
|
|
|
static const zano = CardDesign(imagePath: "assets/new-ui/balance_card_icons/zano.svg");
|
|
|
|
static const wow = CardDesign(imagePath: "assets/new-ui/balance_card_icons/wownero.svg");
|
|
|
|
static const dcr = CardDesign(imagePath: "assets/new-ui/balance_card_icons/decred.svg");
|
|
|
|
static const arbitrum = CardDesign(imagePath: "assets/new-ui/balance_card_icons/arbitrum.svg");
|
|
|
|
static const zec = CardDesign(imagePath: "assets/new-ui/balance_card_icons/zcash.svg");
|
|
|
|
static const bnb = CardDesign(imagePath: "assets/new-ui/balance_card_icons/bnb.svg");
|
|
|
|
static const ethSpecial = CardDesign(
|
|
gradient: const LinearGradient(
|
|
colors: <Color>[Color(0xFF6259FF), Color(0xFF3B20E6)],
|
|
begin: Alignment.topCenter,
|
|
end: Alignment.bottomCenter),
|
|
backgroundType: CardDesignBackgroundTypes.svgFull,
|
|
colors: CardColorCombination.light,
|
|
imagePath: "assets/new-ui/balance_card_backgrounds/ethereum.svg");
|
|
|
|
static const btcSpecial = CardDesign(
|
|
gradient: const LinearGradient(
|
|
colors: <Color>[Color(0xFFFFBF00), Color(0xFFFF6A00)],
|
|
begin: Alignment.topCenter,
|
|
end: Alignment.bottomCenter),
|
|
backgroundType: CardDesignBackgroundTypes.svgFull,
|
|
imagePath: "assets/new-ui/balance_card_backgrounds/bitcoin.svg");
|
|
|
|
static const xmrSpecial = CardDesign(
|
|
gradient: const LinearGradient(
|
|
colors: <Color>[Color(0xFFFF5900), Color(0xFFE62E00)],
|
|
begin: Alignment.topCenter,
|
|
end: Alignment.bottomCenter),
|
|
backgroundType: CardDesignBackgroundTypes.svgFull,
|
|
imagePath: "assets/new-ui/balance_card_backgrounds/monero.svg");
|
|
|
|
static const ltcSpecial = CardDesign(
|
|
gradient: const LinearGradient(
|
|
colors: <Color>[Color(0xFF2145BF), Color(0xFF072071)],
|
|
begin: Alignment.topCenter,
|
|
end: Alignment.bottomCenter),
|
|
backgroundType: CardDesignBackgroundTypes.svgFull,
|
|
colors: CardColorCombination.light,
|
|
imagePath: "assets/new-ui/balance_card_backgrounds/litecoin.svg");
|
|
|
|
static const lnSpecial = CardDesign(
|
|
gradient: const LinearGradient(
|
|
colors: <Color>[Color(0xFFFFBF00), Color(0xFFFF6A00)],
|
|
begin: Alignment.topCenter,
|
|
end: Alignment.bottomCenter),
|
|
backgroundType: CardDesignBackgroundTypes.svgFull,
|
|
colors: CardColorCombination.dark,
|
|
imagePath: "assets/new-ui/balance_card_backgrounds/lightning.svg");
|
|
|
|
static const tronSpecial = CardDesign(
|
|
gradient: const LinearGradient(
|
|
colors: <Color>[Color(0xFFFF1313), Color(0xFFB40000)],
|
|
begin: Alignment.topCenter,
|
|
end: Alignment.bottomCenter),
|
|
backgroundType: CardDesignBackgroundTypes.svgFull,
|
|
colors: CardColorCombination.light,
|
|
imagePath: "assets/new-ui/balance_card_backgrounds/tron.svg");
|
|
|
|
static const solSpecial = CardDesign(
|
|
gradient: const LinearGradient(
|
|
colors: <Color>[Color(0xFF4701AA), Color(0xFF19004B)],
|
|
begin: Alignment.topCenter,
|
|
end: Alignment.bottomCenter),
|
|
backgroundType: CardDesignBackgroundTypes.svgFull,
|
|
colors: CardColorCombination.light,
|
|
imagePath: "assets/new-ui/balance_card_backgrounds/solana.svg");
|
|
|
|
static const bchSpecial = CardDesign(
|
|
gradient: const LinearGradient(
|
|
colors: <Color>[Color(0xFF36DA4C), Color(0xFF008D57)],
|
|
begin: Alignment.topCenter,
|
|
end: Alignment.bottomCenter),
|
|
backgroundType: CardDesignBackgroundTypes.svgFull,
|
|
imagePath: "assets/new-ui/balance_card_backgrounds/bitcoin-cash.svg");
|
|
|
|
static const wowSpecial = CardDesign(
|
|
gradient: const LinearGradient(
|
|
colors: <Color>[Color(0xFFFF6CD3), Color(0xFFF200A9)],
|
|
begin: Alignment.topCenter,
|
|
end: Alignment.bottomCenter),
|
|
backgroundType: CardDesignBackgroundTypes.svgFull,
|
|
imagePath: "assets/new-ui/balance_card_backgrounds/wownero.svg");
|
|
|
|
static const dogeSpecial = CardDesign(
|
|
gradient: const LinearGradient(
|
|
colors: <Color>[Color(0xFFCBA818), Color(0xFF885D00)],
|
|
begin: Alignment.topCenter,
|
|
end: Alignment.bottomCenter),
|
|
backgroundType: CardDesignBackgroundTypes.svgFull,
|
|
imagePath: "assets/new-ui/balance_card_backgrounds/dogecoin.svg");
|
|
|
|
static const nanoSpecial = CardDesign(
|
|
gradient: const LinearGradient(
|
|
colors: <Color>[Color(0xFF209CE9), Color(0xFF0073CB)],
|
|
begin: Alignment.topCenter,
|
|
end: Alignment.bottomCenter),
|
|
backgroundType: CardDesignBackgroundTypes.svgFull,
|
|
imagePath: "assets/new-ui/balance_card_backgrounds/nano.svg");
|
|
|
|
static const polSpecial = CardDesign(
|
|
gradient: const LinearGradient(
|
|
colors: <Color>[Color(0xFF863FE3), Color(0xFF59098E)],
|
|
begin: Alignment.topCenter,
|
|
end: Alignment.bottomCenter),
|
|
backgroundType: CardDesignBackgroundTypes.svgFull,
|
|
colors: CardColorCombination.light,
|
|
imagePath: "assets/new-ui/balance_card_backgrounds/polygon.svg");
|
|
|
|
static const dcrSpecial = CardDesign(
|
|
gradient: const LinearGradient(
|
|
colors: <Color>[Color(0xFF2871FF), Color(0xFF0057FF)],
|
|
begin: Alignment.topCenter,
|
|
end: Alignment.bottomCenter),
|
|
colors: CardColorCombination.light,
|
|
backgroundType: CardDesignBackgroundTypes.svgFull,
|
|
imagePath: "assets/new-ui/balance_card_backgrounds/decred.svg");
|
|
|
|
static const zanoSpecial = CardDesign(
|
|
gradient: const LinearGradient(
|
|
colors: <Color>[Color(0xFF0004B4), Color(0xFF170069)],
|
|
begin: Alignment.topCenter,
|
|
end: Alignment.bottomCenter),
|
|
colors: CardColorCombination.black,
|
|
backgroundType: CardDesignBackgroundTypes.svgFull,
|
|
imagePath: "assets/new-ui/balance_card_backgrounds/zano.svg");
|
|
|
|
static const baseSpecial = CardDesign(
|
|
gradient: const LinearGradient(
|
|
colors: <Color>[Color(0xFF003CFF), Color(0xFF000087)],
|
|
begin: Alignment.topCenter,
|
|
end: Alignment.bottomCenter),
|
|
colors: CardColorCombination.light,
|
|
backgroundType: CardDesignBackgroundTypes.svgFull,
|
|
imagePath: "assets/new-ui/balance_card_backgrounds/base.svg");
|
|
|
|
static const arbitrumSpecial = CardDesign(
|
|
gradient: const LinearGradient(
|
|
colors: <Color>[Color(0xFF173F76), Color(0xFF031A39)],
|
|
begin: Alignment.topCenter,
|
|
end: Alignment.bottomCenter),
|
|
colors: CardColorCombination.light,
|
|
backgroundType: CardDesignBackgroundTypes.svgFull,
|
|
imagePath: "assets/new-ui/balance_card_backgrounds/arbitrum.svg");
|
|
|
|
static const zecSpecial = CardDesign(
|
|
gradient: const LinearGradient(
|
|
colors: <Color>[Color(0xFFF6C527), Color(0xFFCD8C00)],
|
|
begin: Alignment.topCenter,
|
|
end: Alignment.bottomCenter),
|
|
backgroundType: CardDesignBackgroundTypes.svgFull,
|
|
imagePath: "assets/new-ui/balance_card_backgrounds/zcash.svg");
|
|
|
|
static const bnbSpecial = CardDesign(
|
|
gradient: const LinearGradient(
|
|
colors: <Color>[Color(0xFF603000), Color(0xFFF0B90B)],
|
|
begin: Alignment.topCenter,
|
|
end: Alignment.bottomCenter),
|
|
colors: CardColorCombination.light,
|
|
backgroundType: CardDesignBackgroundTypes.svgFull,
|
|
imagePath: "assets/new-ui/balance_card_backgrounds/bnb.svg");
|
|
|
|
CardDesign withGradient(Gradient gradient) => CardDesign(
|
|
gradient: gradient,
|
|
colors: preferredColorCombinations[gradient] ?? colors,
|
|
imagePath: imagePath,
|
|
backgroundType: backgroundType,
|
|
preColoredIcon: preColoredIcon);
|
|
|
|
CardDesign withGradientAndColorCombination(
|
|
Gradient gradient, CardColorCombination cardColorCombination) =>
|
|
CardDesign(
|
|
gradient: gradient,
|
|
colors: cardColorCombination,
|
|
imagePath: imagePath,
|
|
backgroundType: backgroundType,
|
|
preColoredIcon: preColoredIcon);
|
|
|
|
CardDesign withIcon(CardIconPath icon) => CardDesign(
|
|
gradient: gradient,
|
|
colors: colors,
|
|
imagePath: icon.path,
|
|
backgroundType: backgroundType,
|
|
preColoredIcon: icon.preColored);
|
|
|
|
static const String _balanceCardIconPrefix = "assets/new-ui/balance_card_icons";
|
|
static const String _chainIconPrefix = "assets/new-ui/card_icons/chain_icons";
|
|
static const String _ogIconPrefix = "assets/new-ui/card_icons/og_icons";
|
|
static const String _outlineIconPrefix = "assets/new-ui/card_icons/outline_icons";
|
|
static const String _symbolIconPrefix = "assets/new-ui/card_icons/symbol_icons";
|
|
static const String _genericCakeIcon = "$_balanceCardIconPrefix/cake-card-icon.svg";
|
|
|
|
static const Map<CryptoCurrency, _CurrencyIconNames> _iconNames = {
|
|
CryptoCurrency.arbEth: _CurrencyIconNames(ticker: 'arb', longName: 'arbitrum'),
|
|
CryptoCurrency.baseEth:
|
|
_CurrencyIconNames(ticker: 'base', longName: 'base', chainFile: 'base_icon'),
|
|
CryptoCurrency.bch:
|
|
_CurrencyIconNames(ticker: 'bch', longName: 'bitcoin_cash', chainFile: 'bitcoin-cash'),
|
|
CryptoCurrency.btc: _CurrencyIconNames(ticker: 'btc', longName: 'bitcoin', outlineFile: 'BTC'),
|
|
CryptoCurrency.bnb: _CurrencyIconNames(ticker: 'bnb', longName: 'bnb'),
|
|
CryptoCurrency.dcr: _CurrencyIconNames(ticker: 'dcr', longName: 'decred'),
|
|
CryptoCurrency.doge: _CurrencyIconNames(ticker: 'doge', longName: 'dogecoin'),
|
|
CryptoCurrency.eth: _CurrencyIconNames(ticker: 'eth', longName: 'ethereum'),
|
|
CryptoCurrency.btcln: _CurrencyIconNames(ticker: 'ln', longName: 'lightning'),
|
|
CryptoCurrency.ltc: _CurrencyIconNames(ticker: 'ltc', longName: 'litecoin'),
|
|
CryptoCurrency.xmr:
|
|
_CurrencyIconNames(ticker: 'xmr', longName: 'monero', ogPath: 'assets/images/xmr-og.webp'),
|
|
CryptoCurrency.nano: _CurrencyIconNames(ticker: 'xno', longName: 'nano'),
|
|
CryptoCurrency.maticpoly: _CurrencyIconNames(ticker: 'pol', longName: 'polygon'),
|
|
CryptoCurrency.sol: _CurrencyIconNames(ticker: 'sol', longName: 'solana'),
|
|
CryptoCurrency.trx:
|
|
_CurrencyIconNames(ticker: 'trx', longName: 'tron', ogPath: '$_ogIconPrefix/tron-og.svg'),
|
|
CryptoCurrency.zano: _CurrencyIconNames(ticker: 'zano', longName: 'zano'),
|
|
CryptoCurrency.zec: _CurrencyIconNames(ticker: 'zec', longName: 'zcash'),
|
|
};
|
|
|
|
static List<CardIconPath> iconPathsForWalletType(CryptoCurrency currency) {
|
|
final n = _iconNames[currency];
|
|
if (n == null) return const [];
|
|
|
|
return [
|
|
CardIconPath('$_symbolIconPrefix/${n.ticker}-symbol.svg'),
|
|
CardIconPath('$_outlineIconPrefix/${n.outlineFile ?? n.ticker}-outline.svg'),
|
|
CardIconPath('$_balanceCardIconPrefix/${n.longName}.svg'),
|
|
CardIconPath('$_chainIconPrefix/${n.chainFile ?? n.longName}.svg', preColored: true),
|
|
CardIconPath(n.ogPath ?? '$_ogIconPrefix/${n.ticker}-og.svg', preColored: true),
|
|
const CardIconPath(_genericCakeIcon),
|
|
];
|
|
}
|
|
|
|
static const List<CardDesign> all = [
|
|
genericDefault,
|
|
btc,
|
|
eth,
|
|
xmr,
|
|
ltc,
|
|
eth,
|
|
pol,
|
|
doge,
|
|
base,
|
|
sol,
|
|
btcln,
|
|
tron,
|
|
zano,
|
|
dcr,
|
|
arbitrum,
|
|
zec,
|
|
bnb,
|
|
ethSpecial,
|
|
btcSpecial,
|
|
xmrSpecial,
|
|
ltcSpecial,
|
|
lnSpecial,
|
|
tronSpecial,
|
|
bchSpecial,
|
|
wowSpecial,
|
|
dogeSpecial,
|
|
polSpecial,
|
|
dcrSpecial,
|
|
zanoSpecial,
|
|
arbitrumSpecial,
|
|
zecSpecial,
|
|
bnbSpecial
|
|
];
|
|
|
|
static CardDesign forCurrencySpecial(CryptoCurrency currency) {
|
|
return specialDesignsForCurrencies[currency] ?? genericDefault;
|
|
}
|
|
|
|
static CardDesign forCurrencyIcon(CryptoCurrency currency) {
|
|
return iconDesignsForCurrencies[currency] ?? genericDefault;
|
|
}
|
|
|
|
static const Map<CryptoCurrency, CardDesign> iconDesignsForCurrencies = {
|
|
CryptoCurrency.xmr: xmr,
|
|
CryptoCurrency.btc: btc,
|
|
CryptoCurrency.eth: eth,
|
|
CryptoCurrency.ltc: ltc,
|
|
CryptoCurrency.btcln: btcln,
|
|
CryptoCurrency.trx: tron,
|
|
CryptoCurrency.sol: sol,
|
|
CryptoCurrency.maticpoly: pol,
|
|
CryptoCurrency.baseEth: base,
|
|
CryptoCurrency.bch: bch,
|
|
CryptoCurrency.wow: wow,
|
|
CryptoCurrency.doge: doge,
|
|
CryptoCurrency.nano: nano,
|
|
CryptoCurrency.zano: zano,
|
|
CryptoCurrency.arbEth: arbitrum,
|
|
CryptoCurrency.zec: zec,
|
|
CryptoCurrency.dcr: dcr,
|
|
CryptoCurrency.bnb: bnb,
|
|
};
|
|
|
|
static const Map<CryptoCurrency, CardDesign> specialDesignsForCurrencies = {
|
|
CryptoCurrency.xmr: xmrSpecial,
|
|
CryptoCurrency.btc: btcSpecial,
|
|
CryptoCurrency.eth: ethSpecial,
|
|
CryptoCurrency.ltc: ltcSpecial,
|
|
CryptoCurrency.btcln: lnSpecial,
|
|
CryptoCurrency.trx: tronSpecial,
|
|
CryptoCurrency.sol: solSpecial,
|
|
CryptoCurrency.bch: bchSpecial,
|
|
CryptoCurrency.wow: wowSpecial,
|
|
CryptoCurrency.doge: dogeSpecial,
|
|
CryptoCurrency.nano: nanoSpecial,
|
|
CryptoCurrency.maticpoly: polSpecial,
|
|
CryptoCurrency.dcr: dcrSpecial,
|
|
CryptoCurrency.zano: zanoSpecial,
|
|
CryptoCurrency.baseEth: baseSpecial,
|
|
CryptoCurrency.arbEth: arbitrumSpecial,
|
|
CryptoCurrency.zec: zecSpecial,
|
|
CryptoCurrency.bnb: bnbSpecial,
|
|
};
|
|
|
|
static Map<Gradient, CardColorCombination> preferredColorCombinations = {
|
|
CardDesign.gradientOrange: CardColorCombination.dark,
|
|
CardDesign.gradientYellow: CardColorCombination.dark,
|
|
CardDesign.gradientGreen: CardColorCombination.light,
|
|
CardDesign.gradientBlue: CardColorCombination.dark,
|
|
CardDesign.gradientPurple: CardColorCombination.light,
|
|
CardDesign.gradientPink: CardColorCombination.dark,
|
|
CardDesign.gradientRed: CardColorCombination.light,
|
|
CardDesign.gradientSilver: CardColorCombination.dark,
|
|
CardDesign.gradientGold: CardColorCombination.dark,
|
|
CardDesign.gradientBlack: CardColorCombination.black,
|
|
};
|
|
|
|
CardDesign withIconStyleIndex(int iconStyleIndex, CryptoCurrency currency) {
|
|
final paths = iconPathsForWalletType(currency);
|
|
if (paths.isEmpty) return this;
|
|
if (iconStyleIndex < 0 || iconStyleIndex >= paths.length) return this;
|
|
return withIcon(paths[iconStyleIndex]);
|
|
}
|
|
|
|
static Gradient gradientForStoredIndex(
|
|
int gradientIndex,
|
|
CryptoCurrency walletCurrency,
|
|
) {
|
|
final n = CardDesign.allGradients.length;
|
|
final special = specialDesignsForCurrencies[walletCurrency];
|
|
if (gradientIndex >= 0 && gradientIndex < n) {
|
|
return CardDesign.allGradients[gradientIndex];
|
|
}
|
|
if (gradientIndex == n && special != null) {
|
|
return special.gradient;
|
|
}
|
|
return gradientBlue;
|
|
}
|
|
|
|
static CardDesign fromStyleSettings(
|
|
BalanceCardStyleSettings? setting, CryptoCurrency walletCurrency) {
|
|
if (setting == null) {
|
|
return CardDesign.forCurrencySpecial(walletCurrency);
|
|
}
|
|
|
|
if (setting.isGradientOnly) {
|
|
final gradient = gradientForStoredIndex(setting.gradientIndex, walletCurrency);
|
|
final textColors = preferredColorCombinations[gradient] ??
|
|
specialDesignsForCurrencies[walletCurrency]?.colors ??
|
|
gradientOnlyDesign.colors;
|
|
return gradientOnlyDesign.withGradientAndColorCombination(gradient, textColors);
|
|
}
|
|
|
|
if (setting.backgroundImagePath.isNotEmpty) {
|
|
return CardDesign(imagePath: setting.backgroundImagePath);
|
|
}
|
|
|
|
if (setting.useSpecialDesign && setting.gradientIndex != -1) {
|
|
return CardDesign.forCurrencySpecial(walletCurrency).withGradient(
|
|
gradientForStoredIndex(setting.gradientIndex, walletCurrency),
|
|
);
|
|
}
|
|
|
|
if (!setting.useSpecialDesign && setting.gradientIndex == -1) {
|
|
final specialColors = specialDesignsForCurrencies[walletCurrency] ?? genericDefault;
|
|
final design = CardDesign.forCurrencyIcon(walletCurrency)
|
|
.withGradientAndColorCombination(specialColors.gradient, specialColors.colors);
|
|
return design.withIconStyleIndex(setting.iconStyleIndex, walletCurrency);
|
|
}
|
|
if (setting.useSpecialDesign) {
|
|
return CardDesign.forCurrencySpecial(walletCurrency);
|
|
}
|
|
if (setting.gradientIndex != -1) {
|
|
final baseIcon = CardDesign.forCurrencyIcon(walletCurrency);
|
|
final gradient = gradientForStoredIndex(setting.gradientIndex, walletCurrency);
|
|
final textColors = preferredColorCombinations[gradient] ??
|
|
specialDesignsForCurrencies[walletCurrency]?.colors ??
|
|
baseIcon.colors;
|
|
return baseIcon
|
|
.withGradientAndColorCombination(gradient, textColors)
|
|
.withIconStyleIndex(setting.iconStyleIndex, walletCurrency);
|
|
}
|
|
printV("somehow, the user saved the design settings with literally no "
|
|
"customization?");
|
|
return CardDesign.forCurrencySpecial(walletCurrency);
|
|
}
|
|
}
|
|
|
|
class _CurrencyIconNames {
|
|
final String ticker;
|
|
final String longName;
|
|
final String? outlineFile;
|
|
final String? chainFile;
|
|
final String? ogPath;
|
|
|
|
const _CurrencyIconNames({
|
|
required this.ticker,
|
|
required this.longName,
|
|
this.outlineFile,
|
|
this.chainFile,
|
|
this.ogPath,
|
|
});
|
|
}
|