qt: use QStandardItemModel
This commit is contained in:
Janus
ThomasV
parent
9350709f13
commit
5473320ce4
@ -65,8 +65,9 @@ class Contacts(dict):
|
||||
|
||||
def pop(self, key):
|
||||
if key in self.keys():
|
||||
dict.pop(self, key)
|
||||
res = dict.pop(self, key)
|
||||
self.save()
|
||||
return res
|
||||
|
||||
def resolve(self, k):
|
||||
if bitcoin.is_address(k):
|
||||
|
||||
@ -31,13 +31,11 @@ from electrum.bitcoin import is_address
|
||||
|
||||
from .util import *
|
||||
|
||||
|
||||
class AddressList(MyTreeWidget):
|
||||
class AddressList(MyTreeView):
|
||||
filter_columns = [0, 1, 2, 3] # Type, Address, Label, Balance
|
||||
|
||||
def __init__(self, parent=None):
|
||||
MyTreeWidget.__init__(self, parent, self.create_menu, [], 2)
|
||||
self.refresh_headers()
|
||||
super().__init__(parent, self.create_menu, 2)
|
||||
self.setSelectionMode(QAbstractItemView.ExtendedSelection)
|
||||
self.setSortingEnabled(True)
|
||||
self.show_change = 0
|
||||
@ -50,6 +48,8 @@ class AddressList(MyTreeWidget):
|
||||
self.used_button.currentIndexChanged.connect(self.toggle_used)
|
||||
for t in [_('All'), _('Unused'), _('Funded'), _('Used')]:
|
||||
self.used_button.addItem(t)
|
||||
self.setModel(QStandardItemModel(self))
|
||||
self.update()
|
||||
|
||||
def get_toolbar_buttons(self):
|
||||
return QLabel(_("Filter:")), self.change_button, self.used_button
|
||||
@ -82,18 +82,19 @@ class AddressList(MyTreeWidget):
|
||||
self.show_used = state
|
||||
self.update()
|
||||
|
||||
def on_update(self):
|
||||
def update(self):
|
||||
self.wallet = self.parent.wallet
|
||||
item = self.currentItem()
|
||||
current_address = item.data(0, Qt.UserRole) if item else None
|
||||
current_address = self.current_item_user_role(col=2)
|
||||
if self.show_change == 1:
|
||||
addr_list = self.wallet.get_receiving_addresses()
|
||||
elif self.show_change == 2:
|
||||
addr_list = self.wallet.get_change_addresses()
|
||||
else:
|
||||
addr_list = self.wallet.get_addresses()
|
||||
self.clear()
|
||||
self.model().clear()
|
||||
self.refresh_headers()
|
||||
fx = self.parent.fx
|
||||
set_address = None
|
||||
for address in addr_list:
|
||||
num = self.wallet.get_address_history_len(address)
|
||||
label = self.wallet.labels.get(address, '')
|
||||
@ -111,61 +112,66 @@ class AddressList(MyTreeWidget):
|
||||
if fx and fx.get_fiat_address_config():
|
||||
rate = fx.exchange_rate()
|
||||
fiat_balance = fx.value_str(balance, rate)
|
||||
address_item = SortableTreeWidgetItem(['', address, label, balance_text, fiat_balance, "%d"%num])
|
||||
labels = ['', address, label, balance_text, fiat_balance, "%d"%num]
|
||||
address_item = [QStandardItem(e) for e in labels]
|
||||
else:
|
||||
address_item = SortableTreeWidgetItem(['', address, label, balance_text, "%d"%num])
|
||||
labels = ['', address, label, balance_text, "%d"%num]
|
||||
address_item = [QStandardItem(e) for e in labels]
|
||||
# align text and set fonts
|
||||
for i in range(address_item.columnCount()):
|
||||
address_item.setTextAlignment(i, Qt.AlignVCenter)
|
||||
for i, item in enumerate(address_item):
|
||||
item.setTextAlignment(Qt.AlignVCenter)
|
||||
if i not in (0, 2):
|
||||
address_item.setFont(i, QFont(MONOSPACE_FONT))
|
||||
item.setFont(QFont(MONOSPACE_FONT))
|
||||
item.setEditable(i in self.editable_columns)
|
||||
if fx and fx.get_fiat_address_config():
|
||||
address_item.setTextAlignment(4, Qt.AlignRight | Qt.AlignVCenter)
|
||||
address_item[4].setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
|
||||
# setup column 0
|
||||
if self.wallet.is_change(address):
|
||||
address_item.setText(0, _('change'))
|
||||
address_item.setBackground(0, ColorScheme.YELLOW.as_color(True))
|
||||
address_item[0].setText(_('change'))
|
||||
address_item[0].setBackground(ColorScheme.YELLOW.as_color(True))
|
||||
else:
|
||||
address_item.setText(0, _('receiving'))
|
||||
address_item.setBackground(0, ColorScheme.GREEN.as_color(True))
|
||||
address_item.setData(0, Qt.UserRole, address) # column 0; independent from address column
|
||||
address_item[0].setText(_('receiving'))
|
||||
address_item[0].setBackground(ColorScheme.GREEN.as_color(True))
|
||||
address_item[2].setData(address, Qt.UserRole)
|
||||
# setup column 1
|
||||
if self.wallet.is_frozen(address):
|
||||
address_item.setBackground(1, ColorScheme.BLUE.as_color(True))
|
||||
address_item[1].setBackground(ColorScheme.BLUE.as_color(True))
|
||||
if self.wallet.is_beyond_limit(address):
|
||||
address_item.setBackground(1, ColorScheme.RED.as_color(True))
|
||||
address_item[1].setBackground(ColorScheme.RED.as_color(True))
|
||||
# add item
|
||||
self.addChild(address_item)
|
||||
count = self.model().rowCount()
|
||||
self.model().insertRow(count, address_item)
|
||||
address_idx = self.model().index(count, 2)
|
||||
if address == current_address:
|
||||
self.setCurrentItem(address_item)
|
||||
set_address = QPersistentModelIndex(address_idx)
|
||||
self.set_current_idx(set_address)
|
||||
|
||||
def create_menu(self, position):
|
||||
from electrum.wallet import Multisig_Wallet
|
||||
is_multisig = isinstance(self.wallet, Multisig_Wallet)
|
||||
can_delete = self.wallet.can_delete_address()
|
||||
selected = self.selectedItems()
|
||||
selected = self.selected_in_column(1)
|
||||
multi_select = len(selected) > 1
|
||||
addrs = [item.text(1) for item in selected]
|
||||
if not addrs:
|
||||
return
|
||||
addrs = [self.model().itemFromIndex(item).text() for item in selected]
|
||||
if not multi_select:
|
||||
item = self.itemAt(position)
|
||||
col = self.currentColumn()
|
||||
idx = self.indexAt(position)
|
||||
col = idx.column()
|
||||
item = self.model().itemFromIndex(idx)
|
||||
if not item:
|
||||
return
|
||||
addr = addrs[0]
|
||||
if not is_address(addr):
|
||||
item.setExpanded(not item.isExpanded())
|
||||
return
|
||||
|
||||
menu = QMenu()
|
||||
if not multi_select:
|
||||
column_title = self.headerItem().text(col)
|
||||
copy_text = item.text(col)
|
||||
addr_column_title = self.model().horizontalHeaderItem(2).text()
|
||||
addr_idx = idx.sibling(idx.row(), 2)
|
||||
|
||||
column_title = self.model().horizontalHeaderItem(col).text()
|
||||
copy_text = self.model().itemFromIndex(idx).text()
|
||||
menu.addAction(_("Copy {}").format(column_title), lambda: self.parent.app.clipboard().setText(copy_text))
|
||||
menu.addAction(_('Details'), lambda: self.parent.show_address(addr))
|
||||
if col in self.editable_columns:
|
||||
menu.addAction(_("Edit {}").format(column_title), lambda: self.editItem(item, col))
|
||||
persistent = QPersistentModelIndex(addr_idx)
|
||||
menu.addAction(_("Edit {}").format(addr_column_title), lambda p=persistent: self.edit(QModelIndex(p)))
|
||||
menu.addAction(_("Request payment"), lambda: self.parent.receive_at(addr))
|
||||
if self.wallet.can_export():
|
||||
menu.addAction(_("Private key"), lambda: self.parent.show_private_key(addr))
|
||||
@ -189,7 +195,3 @@ class AddressList(MyTreeWidget):
|
||||
|
||||
run_hook('receive_menu', menu, addrs, self.wallet)
|
||||
menu.exec_(self.viewport().mapToGlobal(position))
|
||||
|
||||
def on_permit_edit(self, item, column):
|
||||
# labels for headings, e.g. "receiving" or "used" should not be editable
|
||||
return item.childCount() == 0
|
||||
|
||||
@ -34,67 +34,81 @@ from electrum.bitcoin import is_address
|
||||
from electrum.util import block_explorer_URL
|
||||
from electrum.plugin import run_hook
|
||||
|
||||
from .util import MyTreeWidget, import_meta_gui, export_meta_gui
|
||||
from .util import MyTreeView, import_meta_gui, export_meta_gui
|
||||
|
||||
|
||||
class ContactList(MyTreeWidget):
|
||||
class ContactList(MyTreeView):
|
||||
filter_columns = [0, 1] # Key, Value
|
||||
|
||||
def __init__(self, parent):
|
||||
MyTreeWidget.__init__(self, parent, self.create_menu, [_('Name'), _('Address')], 0, [0])
|
||||
super().__init__(parent, self.create_menu, stretch_column=0, editable_columns=[0])
|
||||
self.setModel(QStandardItemModel(self))
|
||||
self.setSelectionMode(QAbstractItemView.ExtendedSelection)
|
||||
self.setSortingEnabled(True)
|
||||
self.update()
|
||||
|
||||
def on_permit_edit(self, item, column):
|
||||
# openalias items shouldn't be editable
|
||||
return item.text(1) != "openalias"
|
||||
def on_edited(self, idx, user_role, text):
|
||||
_type, prior_name = self.parent.contacts.pop(user_role)
|
||||
|
||||
def on_edited(self, item, column, prior):
|
||||
if column == 0: # Remove old contact if renamed
|
||||
self.parent.contacts.pop(prior)
|
||||
self.parent.set_contact(item.text(0), item.text(1))
|
||||
# TODO when min Qt >= 5.11, use siblingAtColumn
|
||||
col_1_sibling = idx.sibling(idx.row(), 1)
|
||||
col_1_item = self.model().itemFromIndex(col_1_sibling)
|
||||
|
||||
self.parent.set_contact(text, col_1_item.text())
|
||||
|
||||
def import_contacts(self):
|
||||
import_meta_gui(self.parent, _('contacts'), self.parent.contacts.import_file, self.on_update)
|
||||
import_meta_gui(self.parent, _('contacts'), self.parent.contacts.import_file, self.update)
|
||||
|
||||
def export_contacts(self):
|
||||
export_meta_gui(self.parent, _('contacts'), self.parent.contacts.export_file)
|
||||
|
||||
def create_menu(self, position):
|
||||
menu = QMenu()
|
||||
selected = self.selectedItems()
|
||||
if not selected:
|
||||
selected = self.selected_in_column(0)
|
||||
selected_keys = []
|
||||
for idx in selected:
|
||||
sel_key = self.model().itemFromIndex(idx).data(Qt.UserRole)
|
||||
selected_keys.append(sel_key)
|
||||
idx = self.indexAt(position)
|
||||
if not selected or not idx.isValid():
|
||||
menu.addAction(_("New contact"), lambda: self.parent.new_contact_dialog())
|
||||
menu.addAction(_("Import file"), lambda: self.import_contacts())
|
||||
menu.addAction(_("Export file"), lambda: self.export_contacts())
|
||||
else:
|
||||
names = [item.text(0) for item in selected]
|
||||
keys = [item.text(1) for item in selected]
|
||||
column = self.currentColumn()
|
||||
column_title = self.headerItem().text(column)
|
||||
column_data = '\n'.join([item.text(column) for item in selected])
|
||||
column = idx.column()
|
||||
column_title = self.model().horizontalHeaderItem(column).text()
|
||||
column_data = '\n'.join(self.model().itemFromIndex(idx).text() for idx in selected)
|
||||
menu.addAction(_("Copy {}").format(column_title), lambda: self.parent.app.clipboard().setText(column_data))
|
||||
if column in self.editable_columns:
|
||||
item = self.currentItem()
|
||||
menu.addAction(_("Edit {}").format(column_title), lambda: self.editItem(item, column))
|
||||
menu.addAction(_("Pay to"), lambda: self.parent.payto_contacts(keys))
|
||||
menu.addAction(_("Delete"), lambda: self.parent.delete_contacts(keys))
|
||||
URLs = [block_explorer_URL(self.config, 'addr', key) for key in filter(is_address, keys)]
|
||||
item = self.model().itemFromIndex(idx)
|
||||
if item.isEditable():
|
||||
# would not be editable if openalias
|
||||
persistent = QPersistentModelIndex(idx)
|
||||
menu.addAction(_("Edit {}").format(column_title), lambda p=persistent: self.edit(QModelIndex(p)))
|
||||
menu.addAction(_("Pay to"), lambda: self.parent.payto_contacts(selected_keys))
|
||||
menu.addAction(_("Delete"), lambda: self.parent.delete_contacts(selected_keys))
|
||||
URLs = [block_explorer_URL(self.config, 'addr', key) for key in filter(is_address, selected_keys)]
|
||||
if URLs:
|
||||
menu.addAction(_("View on block explorer"), lambda: map(webbrowser.open, URLs))
|
||||
|
||||
run_hook('create_contact_menu', menu, selected)
|
||||
run_hook('create_contact_menu', menu, selected_keys)
|
||||
menu.exec_(self.viewport().mapToGlobal(position))
|
||||
|
||||
def on_update(self):
|
||||
item = self.currentItem()
|
||||
current_key = item.data(0, Qt.UserRole) if item else None
|
||||
self.clear()
|
||||
def update(self):
|
||||
current_key = self.current_item_user_role(col=0)
|
||||
self.model().clear()
|
||||
self.update_headers([_('Name'), _('Address')])
|
||||
set_current = None
|
||||
for key in sorted(self.parent.contacts.keys()):
|
||||
_type, name = self.parent.contacts[key]
|
||||
item = QTreeWidgetItem([name, key])
|
||||
item.setData(0, Qt.UserRole, key)
|
||||
self.addTopLevelItem(item)
|
||||
contact_type, name = self.parent.contacts[key]
|
||||
items = [QStandardItem(x) for x in (name, key)]
|
||||
items[0].setEditable(contact_type != 'openalias')
|
||||
items[1].setEditable(False)
|
||||
items[0].setData(key, Qt.UserRole)
|
||||
row_count = self.model().rowCount()
|
||||
self.model().insertRow(row_count, items)
|
||||
if key == current_key:
|
||||
self.setCurrentItem(item)
|
||||
idx = self.model().index(row_count, 0)
|
||||
set_current = QPersistentModelIndex(idx)
|
||||
self.set_current_idx(set_current)
|
||||
run_hook('update_contacts_tab', self)
|
||||
|
||||
@ -27,10 +27,11 @@ import webbrowser
|
||||
import datetime
|
||||
from datetime import date
|
||||
from typing import TYPE_CHECKING
|
||||
from collections import OrderedDict
|
||||
|
||||
from electrum.address_synchronizer import TX_HEIGHT_LOCAL
|
||||
from electrum.i18n import _
|
||||
from electrum.util import block_explorer_URL, profiler, print_error, TxMinedStatus
|
||||
from electrum.util import block_explorer_URL, profiler, print_error, TxMinedStatus, Fiat
|
||||
|
||||
from .util import *
|
||||
|
||||
@ -57,40 +58,111 @@ TX_ICONS = [
|
||||
"confirmed.png",
|
||||
]
|
||||
|
||||
class HistorySortModel(QSortFilterProxyModel):
|
||||
def lessThan(self, source_left: QModelIndex, source_right: QModelIndex):
|
||||
item1 = self.sourceModel().itemFromIndex(source_left)
|
||||
item2 = self.sourceModel().itemFromIndex(source_right)
|
||||
data1 = item1.data(HistoryList.SORT_ROLE)
|
||||
data2 = item2.data(HistoryList.SORT_ROLE)
|
||||
if data1 is not None and data2 is not None:
|
||||
return data1 < data2
|
||||
return item1.text() < item2.text()
|
||||
|
||||
class HistoryList(MyTreeWidget, AcceptFileDragDrop):
|
||||
filter_columns = [2, 3, 4] # Date, Description, Amount
|
||||
class HistoryList(MyTreeView, AcceptFileDragDrop):
|
||||
filter_columns = [1, 2, 3] # Date, Description, Amount
|
||||
TX_HASH_ROLE = Qt.UserRole
|
||||
TX_VALUE_ROLE = Qt.UserRole + 1
|
||||
SORT_ROLE = Qt.UserRole + 1
|
||||
|
||||
def should_hide(self, proxy_row):
|
||||
if self.start_timestamp and self.end_timestamp:
|
||||
source_idx = self.proxy.mapToSource(self.proxy.index(proxy_row, 0))
|
||||
item = self.std_model.itemFromIndex(source_idx)
|
||||
txid = item.data(self.TX_HASH_ROLE)
|
||||
date = self.transactions[txid]['date']
|
||||
if date:
|
||||
in_interval = self.start_timestamp <= date <= self.end_timestamp
|
||||
if not in_interval:
|
||||
return True
|
||||
return False
|
||||
|
||||
def __init__(self, parent=None):
|
||||
MyTreeWidget.__init__(self, parent, self.create_menu, [], 3)
|
||||
super().__init__(parent, self.create_menu, 2)
|
||||
self.std_model = QStandardItemModel(self)
|
||||
self.proxy = HistorySortModel(self)
|
||||
self.proxy.setSourceModel(self.std_model)
|
||||
self.setModel(self.proxy)
|
||||
|
||||
self.txid_to_items = {}
|
||||
self.transactions = OrderedDict()
|
||||
self.summary = {}
|
||||
self.blue_brush = QBrush(QColor("#1E1EFF"))
|
||||
self.red_brush = QBrush(QColor("#BC1E1E"))
|
||||
self.monospace_font = QFont(MONOSPACE_FONT)
|
||||
self.default_color = self.parent.app.palette().text().color()
|
||||
self.config = parent.config
|
||||
AcceptFileDragDrop.__init__(self, ".txn")
|
||||
self.refresh_headers()
|
||||
self.setColumnHidden(1, True)
|
||||
self.setSortingEnabled(True)
|
||||
self.sortByColumn(0, Qt.AscendingOrder)
|
||||
self.start_timestamp = None
|
||||
self.end_timestamp = None
|
||||
self.years = []
|
||||
self.create_toolbar_buttons()
|
||||
self.wallet = None
|
||||
|
||||
root = self.std_model.invisibleRootItem()
|
||||
|
||||
self.wallet = self.parent.wallet # type: Abstract_Wallet
|
||||
fx = self.parent.fx
|
||||
r = self.wallet.get_full_history(domain=self.get_domain(), from_timestamp=None, to_timestamp=None, fx=fx)
|
||||
self.transactions.update([(x['txid'], x) for x in r['transactions']])
|
||||
self.summary = r['summary']
|
||||
if not self.years and self.transactions:
|
||||
start_date = next(iter(self.transactions.values())).get('date') or date.today()
|
||||
end_date = next(iter(reversed(self.transactions.values()))).get('date') or date.today()
|
||||
self.years = [str(i) for i in range(start_date.year, end_date.year + 1)]
|
||||
self.period_combo.insertItems(1, self.years)
|
||||
if fx: fx.history_used_spot = False
|
||||
self.refresh_headers()
|
||||
for tx_item in self.transactions.values():
|
||||
self.insert_tx(tx_item)
|
||||
self.sortByColumn(0, Qt.AscendingOrder)
|
||||
|
||||
#def on_activated(self, idx: QModelIndex):
|
||||
# # TODO use siblingAtColumn when min Qt version is >=5.11
|
||||
# self.edit(idx.sibling(idx.row(), 2))
|
||||
|
||||
def format_date(self, d):
|
||||
return str(datetime.date(d.year, d.month, d.day)) if d else _('None')
|
||||
|
||||
def refresh_headers(self):
|
||||
headers = ['', '', _('Date'), _('Description'), _('Amount'), _('Balance')]
|
||||
headers = ['', _('Date'), _('Description'), _('Amount'), _('Balance')]
|
||||
fx = self.parent.fx
|
||||
if fx and fx.show_history():
|
||||
headers.extend(['%s '%fx.ccy + _('Value')])
|
||||
self.editable_columns |= {6}
|
||||
self.editable_columns |= {5}
|
||||
if fx.get_history_capital_gains_config():
|
||||
headers.extend(['%s '%fx.ccy + _('Acquisition price')])
|
||||
headers.extend(['%s '%fx.ccy + _('Capital Gains')])
|
||||
else:
|
||||
self.editable_columns -= {6}
|
||||
self.update_headers(headers)
|
||||
self.editable_columns -= {5}
|
||||
col_count = self.std_model.columnCount()
|
||||
diff = col_count-len(headers)
|
||||
grew = False
|
||||
if col_count > len(headers):
|
||||
if diff == 2:
|
||||
self.std_model.removeColumns(6, diff)
|
||||
else:
|
||||
assert diff in [1, 3]
|
||||
self.std_model.removeColumns(5, diff)
|
||||
for items in self.txid_to_items.values():
|
||||
while len(items) > col_count:
|
||||
items.pop()
|
||||
elif col_count < len(headers):
|
||||
grew = True
|
||||
self.std_model.clear()
|
||||
self.txid_to_items.clear()
|
||||
self.transactions.clear()
|
||||
self.summary.clear()
|
||||
self.update_headers(headers, self.std_model)
|
||||
|
||||
def get_domain(self):
|
||||
'''Replaced in address_dialog.py'''
|
||||
@ -111,13 +183,11 @@ class HistoryList(MyTreeWidget, AcceptFileDragDrop):
|
||||
year = int(s)
|
||||
except:
|
||||
return
|
||||
start_date = datetime.datetime(year, 1, 1)
|
||||
end_date = datetime.datetime(year+1, 1, 1)
|
||||
self.start_timestamp = time.mktime(start_date.timetuple())
|
||||
self.end_timestamp = time.mktime(end_date.timetuple())
|
||||
self.start_timestamp = start_date = datetime.datetime(year, 1, 1)
|
||||
self.end_timestamp = end_date = datetime.datetime(year+1, 1, 1)
|
||||
self.start_button.setText(_('From') + ' ' + self.format_date(start_date))
|
||||
self.end_button.setText(_('To') + ' ' + self.format_date(end_date))
|
||||
self.update()
|
||||
self.hide_rows()
|
||||
|
||||
def create_toolbar_buttons(self):
|
||||
self.period_combo = QComboBox()
|
||||
@ -136,18 +206,18 @@ class HistoryList(MyTreeWidget, AcceptFileDragDrop):
|
||||
def on_hide_toolbar(self):
|
||||
self.start_timestamp = None
|
||||
self.end_timestamp = None
|
||||
self.update()
|
||||
self.hide_rows()
|
||||
|
||||
def save_toolbar_state(self, state, config):
|
||||
config.set_key('show_toolbar_history', state)
|
||||
|
||||
def select_start_date(self):
|
||||
self.start_timestamp = self.select_date(self.start_button)
|
||||
self.update()
|
||||
self.hide_rows()
|
||||
|
||||
def select_end_date(self):
|
||||
self.end_timestamp = self.select_date(self.end_button)
|
||||
self.update()
|
||||
self.hide_rows()
|
||||
|
||||
def select_date(self, button):
|
||||
d = WindowModalDialog(self, _("Select date"))
|
||||
@ -167,7 +237,7 @@ class HistoryList(MyTreeWidget, AcceptFileDragDrop):
|
||||
return None
|
||||
date = d.date.toPyDate()
|
||||
button.setText(self.format_date(date))
|
||||
return time.mktime(date.timetuple())
|
||||
return datetime.datetime(date.year, date.month, date.day)
|
||||
|
||||
def show_summary(self):
|
||||
h = self.summary
|
||||
@ -215,104 +285,167 @@ class HistoryList(MyTreeWidget, AcceptFileDragDrop):
|
||||
_("Perhaps some dependencies are missing...") + " (matplotlib?)")
|
||||
return
|
||||
try:
|
||||
plt = plot_history(self.transactions)
|
||||
plt = plot_history(list(self.transactions.values()))
|
||||
plt.show()
|
||||
except NothingToPlotException as e:
|
||||
self.parent.show_message(str(e))
|
||||
|
||||
def insert_tx(self, tx_item):
|
||||
fx = self.parent.fx
|
||||
tx_hash = tx_item['txid']
|
||||
height = tx_item['height']
|
||||
conf = tx_item['confirmations']
|
||||
timestamp = tx_item['timestamp']
|
||||
value = tx_item['value'].value
|
||||
balance = tx_item['balance'].value
|
||||
label = tx_item['label']
|
||||
tx_mined_status = TxMinedStatus(height, conf, timestamp, None)
|
||||
status, status_str = self.wallet.get_tx_status(tx_hash, tx_mined_status)
|
||||
has_invoice = self.wallet.invoices.paid.get(tx_hash)
|
||||
icon = self.icon_cache.get(":icons/" + TX_ICONS[status])
|
||||
v_str = self.parent.format_amount(value, is_diff=True, whitespaces=True)
|
||||
balance_str = self.parent.format_amount(balance, whitespaces=True)
|
||||
entry = ['', status_str, label, v_str, balance_str]
|
||||
fiat_value = None
|
||||
item = [QStandardItem(e) for e in entry]
|
||||
item[3].setData(value, self.SORT_ROLE)
|
||||
item[4].setData(balance, self.SORT_ROLE)
|
||||
if has_invoice:
|
||||
item[2].setIcon(self.icon_cache.get(":icons/seal"))
|
||||
for i in range(len(entry)):
|
||||
self.set_item_properties(item[i], i, tx_hash)
|
||||
if value and value < 0:
|
||||
item[2].setForeground(self.red_brush)
|
||||
item[3].setForeground(self.red_brush)
|
||||
self.txid_to_items[tx_hash] = item
|
||||
self.update_item(tx_hash, self.parent.wallet.get_tx_height(tx_hash))
|
||||
source_row_idx = self.std_model.rowCount()
|
||||
self.std_model.insertRow(source_row_idx, item)
|
||||
new_idx = self.std_model.index(source_row_idx, 0)
|
||||
history = self.parent.fx.show_history()
|
||||
if history:
|
||||
self.update_fiat(tx_hash, tx_item)
|
||||
self.hide_row(self.proxy.mapFromSource(new_idx).row())
|
||||
|
||||
def set_item_properties(self, item, i, tx_hash):
|
||||
if i>2:
|
||||
item.setTextAlignment(Qt.AlignRight | Qt.AlignVCenter)
|
||||
if i!=1:
|
||||
item.setFont(self.monospace_font)
|
||||
item.setEditable(i in self.editable_columns)
|
||||
item.setData(tx_hash, self.TX_HASH_ROLE)
|
||||
|
||||
def ensure_fields_available(self, items, idx, txid):
|
||||
while len(items) < idx + 1:
|
||||
row = list(self.transactions.keys()).index(txid)
|
||||
qidx = self.std_model.index(row, len(items))
|
||||
assert qidx.isValid(), (self.std_model.columnCount(), idx)
|
||||
item = self.std_model.itemFromIndex(qidx)
|
||||
self.set_item_properties(item, len(items), txid)
|
||||
items.append(item)
|
||||
|
||||
@profiler
|
||||
def on_update(self):
|
||||
def update(self):
|
||||
self.wallet = self.parent.wallet # type: Abstract_Wallet
|
||||
fx = self.parent.fx
|
||||
r = self.wallet.get_full_history(domain=self.get_domain(), from_timestamp=self.start_timestamp, to_timestamp=self.end_timestamp, fx=fx)
|
||||
self.transactions = r['transactions']
|
||||
self.summary = r['summary']
|
||||
if not self.years and self.transactions:
|
||||
start_date = self.transactions[0].get('date') or date.today()
|
||||
end_date = self.transactions[-1].get('date') or date.today()
|
||||
self.years = [str(i) for i in range(start_date.year, end_date.year + 1)]
|
||||
self.period_combo.insertItems(1, self.years)
|
||||
item = self.currentItem()
|
||||
current_tx = item.data(0, self.TX_HASH_ROLE) if item else None
|
||||
self.clear()
|
||||
if fx: fx.history_used_spot = False
|
||||
blue_brush = QBrush(QColor("#1E1EFF"))
|
||||
red_brush = QBrush(QColor("#BC1E1E"))
|
||||
monospace_font = QFont(MONOSPACE_FONT)
|
||||
for tx_item in self.transactions:
|
||||
tx_hash = tx_item['txid']
|
||||
height = tx_item['height']
|
||||
conf = tx_item['confirmations']
|
||||
timestamp = tx_item['timestamp']
|
||||
value_sat = tx_item['value'].value
|
||||
balance = tx_item['balance'].value
|
||||
label = tx_item['label']
|
||||
tx_mined_status = TxMinedStatus(height, conf, timestamp, None)
|
||||
status, status_str = self.wallet.get_tx_status(tx_hash, tx_mined_status)
|
||||
has_invoice = self.wallet.invoices.paid.get(tx_hash)
|
||||
icon = self.icon_cache.get(":icons/" + TX_ICONS[status])
|
||||
v_str = self.parent.format_amount(value_sat, is_diff=True, whitespaces=True)
|
||||
balance_str = self.parent.format_amount(balance, whitespaces=True)
|
||||
entry = ['', tx_hash, status_str, label, v_str, balance_str]
|
||||
fiat_value = None
|
||||
if value_sat is not None and fx and fx.show_history():
|
||||
fiat_value = tx_item['fiat_value'].value
|
||||
value_str = fx.format_fiat(fiat_value)
|
||||
entry.append(value_str)
|
||||
# fixme: should use is_mine
|
||||
if value_sat < 0:
|
||||
entry.append(fx.format_fiat(tx_item['acquisition_price'].value))
|
||||
entry.append(fx.format_fiat(tx_item['capital_gain'].value))
|
||||
item = SortableTreeWidgetItem(entry)
|
||||
item.setIcon(0, icon)
|
||||
item.setToolTip(0, str(conf) + " confirmation" + ("s" if conf != 1 else ""))
|
||||
if has_invoice:
|
||||
item.setIcon(3, self.icon_cache.get(":icons/seal"))
|
||||
for i in range(len(entry)):
|
||||
if i>3:
|
||||
item.setTextAlignment(i, Qt.AlignRight | Qt.AlignVCenter)
|
||||
if i!=2:
|
||||
item.setFont(i, monospace_font)
|
||||
if value_sat and value_sat < 0:
|
||||
item.setForeground(3, red_brush)
|
||||
item.setForeground(4, red_brush)
|
||||
if fiat_value is not None and not tx_item['fiat_default']:
|
||||
item.setForeground(6, blue_brush)
|
||||
# sort orders
|
||||
item.setData(0, SortableTreeWidgetItem.DataRole, (status, conf))
|
||||
item.setData(4, SortableTreeWidgetItem.DataRole, value_sat)
|
||||
item.setData(5, SortableTreeWidgetItem.DataRole, balance)
|
||||
if fiat_value is not None:
|
||||
item.setData(6, SortableTreeWidgetItem.DataRole, fiat_value)
|
||||
if value_sat < 0:
|
||||
item.setData(7, SortableTreeWidgetItem.DataRole, tx_item['acquisition_price'].value)
|
||||
item.setData(8, SortableTreeWidgetItem.DataRole, tx_item['capital_gain'].value)
|
||||
if tx_hash:
|
||||
item.setData(0, self.TX_HASH_ROLE, tx_hash)
|
||||
item.setData(0, self.TX_VALUE_ROLE, value_sat)
|
||||
self.insertTopLevelItem(0, item)
|
||||
if current_tx == tx_hash:
|
||||
self.setCurrentItem(item)
|
||||
r = self.wallet.get_full_history(domain=self.get_domain(), from_timestamp=None, to_timestamp=None, fx=fx)
|
||||
seen = set()
|
||||
history = fx.show_history()
|
||||
tx_list = list(self.transactions.values())
|
||||
if r['transactions'] == tx_list:
|
||||
return
|
||||
if r['transactions'][:-1] == tx_list:
|
||||
print_error('history_list: one new transaction')
|
||||
row = r['transactions'][-1]
|
||||
txid = row['txid']
|
||||
if txid not in self.transactions:
|
||||
self.transactions[txid] = row
|
||||
self.transactions.move_to_end(txid, last=True)
|
||||
self.insert_tx(row)
|
||||
return
|
||||
else:
|
||||
print_error('history_list: tx added but txid is already in list (weird), txid: ', txid)
|
||||
for idx, row in enumerate(r['transactions']):
|
||||
txid = row['txid']
|
||||
seen.add(txid)
|
||||
if txid not in self.transactions:
|
||||
self.transactions[txid] = row
|
||||
self.transactions.move_to_end(txid, last=True)
|
||||
self.insert_tx(row)
|
||||
continue
|
||||
old = self.transactions[txid]
|
||||
if old == row:
|
||||
continue
|
||||
self.update_item(txid, self.parent.wallet.get_tx_height(txid))
|
||||
if history:
|
||||
self.update_fiat(txid, row)
|
||||
balance_str = self.parent.format_amount(row['balance'].value, whitespaces=True)
|
||||
self.txid_to_items[txid][4].setText(balance_str)
|
||||
self.txid_to_items[txid][4].setData(row['balance'].value, self.SORT_ROLE)
|
||||
old.clear()
|
||||
old.update(**row)
|
||||
removed = 0
|
||||
l = list(enumerate(self.transactions.keys()))
|
||||
for idx, txid in l:
|
||||
if txid not in seen:
|
||||
del self.transactions[txid]
|
||||
del self.txid_to_items[txid]
|
||||
items = self.std_model.takeRow(idx - removed)
|
||||
removed_txid = items[0].data(self.TX_HASH_ROLE)
|
||||
assert removed_txid == txid, (idx, removed)
|
||||
removed += 1
|
||||
self.apply_filter()
|
||||
|
||||
def on_edited(self, item, column, prior):
|
||||
'''Called only when the text actually changes'''
|
||||
key = item.data(0, self.TX_HASH_ROLE)
|
||||
value_sat = item.data(0, self.TX_VALUE_ROLE)
|
||||
text = item.text(column)
|
||||
def update_fiat(self, txid, row):
|
||||
cap_gains = self.parent.fx.get_history_capital_gains_config()
|
||||
items = self.txid_to_items[txid]
|
||||
self.ensure_fields_available(items, 7 if cap_gains else 5, txid)
|
||||
items[5].setForeground(self.blue_brush if not row['fiat_default'] and row['fiat_value'] else self.default_color)
|
||||
value_str = self.parent.fx.format_fiat(row['fiat_value'].value)
|
||||
items[5].setText(value_str)
|
||||
items[5].setData(row['fiat_value'].value, self.SORT_ROLE)
|
||||
# fixme: should use is_mine
|
||||
if row['value'].value < 0 and cap_gains:
|
||||
acq = row['acquisition_price'].value
|
||||
items[6].setText(self.parent.fx.format_fiat(acq))
|
||||
items[6].setData(acq, self.SORT_ROLE)
|
||||
cg = row['capital_gain'].value
|
||||
items[7].setText(self.parent.fx.format_fiat(cg))
|
||||
items[7].setData(cg, self.SORT_ROLE)
|
||||
|
||||
def update_on_new_fee_histogram(self):
|
||||
pass
|
||||
# TODO update unconfirmed tx'es
|
||||
|
||||
def on_edited(self, index, user_role, text):
|
||||
column = index.column()
|
||||
index = self.proxy.mapToSource(index)
|
||||
item = self.std_model.itemFromIndex(index)
|
||||
key = item.data(self.TX_HASH_ROLE)
|
||||
# fixme
|
||||
if column == 3:
|
||||
if column == 2:
|
||||
self.parent.wallet.set_label(key, text)
|
||||
self.update_labels()
|
||||
self.parent.update_completions()
|
||||
elif column == 6:
|
||||
self.parent.wallet.set_fiat_value(key, self.parent.fx.ccy, text, self.parent.fx, value_sat)
|
||||
self.on_update()
|
||||
|
||||
def on_doubleclick(self, item, column):
|
||||
if self.permit_edit(item, column):
|
||||
super(HistoryList, self).on_doubleclick(item, column)
|
||||
elif column == 5:
|
||||
tx_item = self.transactions[key]
|
||||
self.parent.wallet.set_fiat_value(key, self.parent.fx.ccy, text, self.parent.fx, tx_item['value'].value)
|
||||
value = tx_item['value'].value
|
||||
if value is not None:
|
||||
fee = tx_item['fee']
|
||||
fiat_fields = self.parent.wallet.get_tx_item_fiat(key, value, self.parent.fx, fee.value if fee else None)
|
||||
tx_item.update(fiat_fields)
|
||||
self.update_fiat(key, tx_item)
|
||||
else:
|
||||
tx_hash = item.data(0, self.TX_HASH_ROLE)
|
||||
assert False
|
||||
|
||||
def mouseDoubleClickEvent(self, event: QMouseEvent):
|
||||
idx = self.indexAt(event.pos())
|
||||
item = self.std_model.itemFromIndex(self.proxy.mapToSource(idx))
|
||||
if not item or item.isEditable():
|
||||
super().mouseDoubleClickEvent(event)
|
||||
elif item:
|
||||
tx_hash = item.data(self.TX_HASH_ROLE)
|
||||
self.show_transaction(tx_hash)
|
||||
|
||||
def show_transaction(self, tx_hash):
|
||||
@ -323,13 +456,13 @@ class HistoryList(MyTreeWidget, AcceptFileDragDrop):
|
||||
self.parent.show_transaction(tx, label)
|
||||
|
||||
def update_labels(self):
|
||||
root = self.invisibleRootItem()
|
||||
child_count = root.childCount()
|
||||
root = self.std_model.invisibleRootItem()
|
||||
child_count = root.rowCount()
|
||||
for i in range(child_count):
|
||||
item = root.child(i)
|
||||
txid = item.data(0, self.TX_HASH_ROLE)
|
||||
item = root.child(i, 2)
|
||||
txid = item.data(self.TX_HASH_ROLE)
|
||||
label = self.wallet.get_label(txid)
|
||||
item.setText(3, label)
|
||||
item.setText(label)
|
||||
|
||||
def update_item(self, tx_hash, tx_mined_status):
|
||||
if self.wallet is None:
|
||||
@ -337,31 +470,30 @@ class HistoryList(MyTreeWidget, AcceptFileDragDrop):
|
||||
conf = tx_mined_status.conf
|
||||
status, status_str = self.wallet.get_tx_status(tx_hash, tx_mined_status)
|
||||
icon = self.icon_cache.get(":icons/" + TX_ICONS[status])
|
||||
items = self.findItems(tx_hash, Qt.MatchExactly, column=1)
|
||||
if items:
|
||||
item = items[0]
|
||||
item.setIcon(0, icon)
|
||||
item.setData(0, SortableTreeWidgetItem.DataRole, (status, conf))
|
||||
item.setText(2, status_str)
|
||||
if tx_hash not in self.txid_to_items:
|
||||
return
|
||||
items = self.txid_to_items[tx_hash]
|
||||
items[0].setIcon(icon)
|
||||
items[0].setToolTip(str(conf) + _(" confirmation" + ("s" if conf != 1 else "")))
|
||||
items[0].setData((status, conf), self.SORT_ROLE)
|
||||
items[1].setText(status_str)
|
||||
|
||||
def create_menu(self, position):
|
||||
self.selectedIndexes()
|
||||
item = self.currentItem()
|
||||
if not item:
|
||||
return
|
||||
column = self.currentColumn()
|
||||
tx_hash = item.data(0, self.TX_HASH_ROLE)
|
||||
if not tx_hash:
|
||||
return
|
||||
def create_menu(self, position: QPoint):
|
||||
org_idx: QModelIndex = self.indexAt(position)
|
||||
idx = self.proxy.mapToSource(org_idx)
|
||||
item: QStandardItem = self.std_model.itemFromIndex(idx)
|
||||
assert item, 'create_menu: index not found in model'
|
||||
tx_hash = idx.data(self.TX_HASH_ROLE)
|
||||
column = idx.column()
|
||||
assert tx_hash, "create_menu: no tx hash"
|
||||
tx = self.wallet.transactions.get(tx_hash)
|
||||
if not tx:
|
||||
return
|
||||
if column is 0:
|
||||
column_title = "ID"
|
||||
assert tx, "create_menu: no tx"
|
||||
if column == 0:
|
||||
column_title = _('Transaction ID')
|
||||
column_data = tx_hash
|
||||
else:
|
||||
column_title = self.headerItem().text(column)
|
||||
column_data = item.text(column)
|
||||
column_title = self.std_model.horizontalHeaderItem(column).text()
|
||||
column_data = item.text()
|
||||
tx_URL = block_explorer_URL(self.config, 'tx', tx_hash)
|
||||
height = self.wallet.get_tx_height(tx_hash).height
|
||||
is_relevant, is_mine, v, fee = self.wallet.get_wallet_delta(tx)
|
||||
@ -372,8 +504,10 @@ class HistoryList(MyTreeWidget, AcceptFileDragDrop):
|
||||
menu.addAction(_("Remove"), lambda: self.remove_local_tx(tx_hash))
|
||||
menu.addAction(_("Copy {}").format(column_title), lambda: self.parent.app.clipboard().setText(column_data))
|
||||
for c in self.editable_columns:
|
||||
menu.addAction(_("Edit {}").format(self.headerItem().text(c)),
|
||||
lambda bound_c=c: self.editItem(item, bound_c))
|
||||
label = self.std_model.horizontalHeaderItem(c).text()
|
||||
# TODO use siblingAtColumn when min Qt version is >=5.11
|
||||
persistent = QPersistentModelIndex(org_idx.sibling(org_idx.row(), c))
|
||||
menu.addAction(_("Edit {}").format(label), lambda p=persistent: self.edit(QModelIndex(p)))
|
||||
menu.addAction(_("Details"), lambda: self.show_transaction(tx_hash))
|
||||
if is_unconfirmed and tx:
|
||||
# note: the current implementation of RBF *needs* the old tx fee
|
||||
@ -442,7 +576,7 @@ class HistoryList(MyTreeWidget, AcceptFileDragDrop):
|
||||
self.parent.show_message(_("Your wallet history has been successfully exported."))
|
||||
|
||||
def do_export_history(self, file_name, is_csv):
|
||||
history = self.transactions
|
||||
history = self.transactions.values()
|
||||
lines = []
|
||||
if is_csv:
|
||||
for item in history:
|
||||
|
||||
@ -29,36 +29,40 @@ from electrum.util import format_time
|
||||
from .util import *
|
||||
|
||||
|
||||
class InvoiceList(MyTreeWidget):
|
||||
class InvoiceList(MyTreeView):
|
||||
filter_columns = [0, 1, 2, 3] # Date, Requestor, Description, Amount
|
||||
|
||||
def __init__(self, parent):
|
||||
MyTreeWidget.__init__(self, parent, self.create_menu, [_('Expires'), _('Requestor'), _('Description'), _('Amount'), _('Status')], 2)
|
||||
super().__init__(parent, self.create_menu, 2)
|
||||
self.setSortingEnabled(True)
|
||||
self.header().setSectionResizeMode(1, QHeaderView.Interactive)
|
||||
self.setColumnWidth(1, 200)
|
||||
self.setModel(QStandardItemModel(self))
|
||||
self.update()
|
||||
|
||||
def on_update(self):
|
||||
def update(self):
|
||||
inv_list = self.parent.invoices.unpaid_invoices()
|
||||
self.clear()
|
||||
self.model().clear()
|
||||
self.update_headers([_('Expires'), _('Requestor'), _('Description'), _('Amount'), _('Status')])
|
||||
self.header().setSectionResizeMode(1, QHeaderView.Interactive)
|
||||
for pr in inv_list:
|
||||
key = pr.get_id()
|
||||
status = self.parent.invoices.get_status(key)
|
||||
requestor = pr.get_requestor()
|
||||
exp = pr.get_expiration_date()
|
||||
date_str = format_time(exp) if exp else _('Never')
|
||||
item = QTreeWidgetItem([date_str, requestor, pr.memo, self.parent.format_amount(pr.get_amount(), whitespaces=True), pr_tooltips.get(status,'')])
|
||||
item.setIcon(4, self.icon_cache.get(pr_icons.get(status)))
|
||||
item.setData(0, Qt.UserRole, key)
|
||||
item.setFont(1, QFont(MONOSPACE_FONT))
|
||||
item.setFont(3, QFont(MONOSPACE_FONT))
|
||||
labels = [date_str, requestor, pr.memo, self.parent.format_amount(pr.get_amount(), whitespaces=True), pr_tooltips.get(status,'')]
|
||||
item = [QStandardItem(e) for e in labels]
|
||||
item[4].setIcon(self.icon_cache.get(pr_icons.get(status)))
|
||||
item[0].setData(Qt.UserRole, key)
|
||||
item[1].setFont(QFont(MONOSPACE_FONT))
|
||||
item[3].setFont(QFont(MONOSPACE_FONT))
|
||||
self.addTopLevelItem(item)
|
||||
self.setCurrentItem(self.topLevelItem(0))
|
||||
self.selectionModel().select(self.model().index(0,0), QItemSelectionModel.SelectCurrent)
|
||||
self.setVisible(len(inv_list))
|
||||
self.parent.invoices_label.setVisible(len(inv_list))
|
||||
|
||||
def import_invoices(self):
|
||||
import_meta_gui(self.parent, _('invoices'), self.parent.invoices.import_file, self.on_update)
|
||||
import_meta_gui(self.parent, _('invoices'), self.parent.invoices.import_file, self.update)
|
||||
|
||||
def export_invoices(self):
|
||||
export_meta_gui(self.parent, _('invoices'), self.parent.invoices.export_file)
|
||||
|
||||
@ -353,8 +353,7 @@ class ElectrumWindow(QMainWindow, MessageBoxMixin, PrintError):
|
||||
if self.config.is_dynfee():
|
||||
self.fee_slider.update()
|
||||
self.do_update_fee()
|
||||
# todo: update only unconfirmed tx
|
||||
self.history_list.update()
|
||||
self.history_list.update_on_new_fee_histogram()
|
||||
else:
|
||||
self.print_error("unexpected network_qt signal:", event, args)
|
||||
|
||||
@ -379,9 +378,6 @@ class ElectrumWindow(QMainWindow, MessageBoxMixin, PrintError):
|
||||
def load_wallet(self, wallet):
|
||||
wallet.thread = TaskThread(self, self.on_error)
|
||||
self.update_recently_visited(wallet.storage.path)
|
||||
# update(==init) all tabs; expensive for large wallets..
|
||||
# so delay it somewhat, hence __init__ can finish and the window can appear sooner
|
||||
QTimer.singleShot(50, self.update_tabs)
|
||||
self.need_update.set()
|
||||
# Once GUI has been initialized check if we want to announce something since the callback has been called before the GUI was initialized
|
||||
# update menus
|
||||
@ -1111,9 +1107,7 @@ class ElectrumWindow(QMainWindow, MessageBoxMixin, PrintError):
|
||||
|
||||
self.from_label = QLabel(_('From'))
|
||||
grid.addWidget(self.from_label, 3, 0)
|
||||
self.from_list = MyTreeWidget(self, self.from_list_menu, ['',''])
|
||||
self.from_list.setHeaderHidden(True)
|
||||
self.from_list.setMaximumHeight(80)
|
||||
self.from_list = FromList(self, self.from_list_menu)
|
||||
grid.addWidget(self.from_list, 3, 1, 1, -1)
|
||||
self.set_pay_from([])
|
||||
|
||||
|
||||
@ -100,7 +100,6 @@ class NodesListWidget(QTreeWidget):
|
||||
|
||||
def update(self, network: Network):
|
||||
self.clear()
|
||||
self.addChild = self.addTopLevelItem
|
||||
chains = network.get_blockchains()
|
||||
n_chains = len(chains)
|
||||
for chain_id, interfaces in chains.items():
|
||||
@ -118,7 +117,7 @@ class NodesListWidget(QTreeWidget):
|
||||
item = QTreeWidgetItem([i.host + star, '%d'%i.tip])
|
||||
item.setData(0, Qt.UserRole, 0)
|
||||
item.setData(1, Qt.UserRole, i.server)
|
||||
x.addChild(item)
|
||||
x.addTopLevelItem(item)
|
||||
if n_chains > 1:
|
||||
self.addTopLevelItem(x)
|
||||
x.setExpanded(True)
|
||||
|
||||
@ -23,43 +23,39 @@
|
||||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
# SOFTWARE.
|
||||
|
||||
from PyQt5.QtGui import *
|
||||
from PyQt5.QtCore import *
|
||||
from PyQt5.QtWidgets import QTreeWidgetItem, QMenu
|
||||
from PyQt5.QtGui import QStandardItemModel, QStandardItem
|
||||
from PyQt5.QtWidgets import QMenu
|
||||
from PyQt5.QtCore import Qt
|
||||
|
||||
from electrum.i18n import _
|
||||
from electrum.util import format_time, age
|
||||
from electrum.plugin import run_hook
|
||||
from electrum.paymentrequest import PR_UNKNOWN
|
||||
|
||||
from .util import MyTreeWidget, pr_tooltips, pr_icons
|
||||
from .util import MyTreeView, pr_tooltips, pr_icons
|
||||
|
||||
|
||||
class RequestList(MyTreeWidget):
|
||||
class RequestList(MyTreeView):
|
||||
filter_columns = [0, 1, 2, 3, 4] # Date, Account, Address, Description, Amount
|
||||
|
||||
|
||||
def __init__(self, parent):
|
||||
MyTreeWidget.__init__(self, parent, self.create_menu, [_('Date'), _('Address'), '', _('Description'), _('Amount'), _('Status')], 3)
|
||||
self.currentItemChanged.connect(self.item_changed)
|
||||
self.itemClicked.connect(self.item_changed)
|
||||
super().__init__(parent, self.create_menu, 3, editable_columns=[])
|
||||
self.setModel(QStandardItemModel(self))
|
||||
self.setSortingEnabled(True)
|
||||
self.setColumnWidth(0, 180)
|
||||
self.hideColumn(1)
|
||||
self.update()
|
||||
self.selectionModel().currentRowChanged.connect(self.item_changed)
|
||||
|
||||
def item_changed(self, item):
|
||||
if item is None:
|
||||
return
|
||||
if not item.isSelected():
|
||||
return
|
||||
addr = str(item.text(1))
|
||||
def item_changed(self, idx):
|
||||
# TODO use siblingAtColumn when min Qt version is >=5.11
|
||||
addr = self.model().itemFromIndex(idx.sibling(idx.row(), 1)).text()
|
||||
req = self.wallet.receive_requests.get(addr)
|
||||
if req is None:
|
||||
self.update()
|
||||
return
|
||||
expires = age(req['time'] + req['exp']) if req.get('exp') else _('Never')
|
||||
amount = req['amount']
|
||||
message = self.wallet.labels.get(addr, '')
|
||||
message = req['memo']
|
||||
self.parent.receive_address_e.setText(addr)
|
||||
self.parent.receive_message_e.setText(message)
|
||||
self.parent.receive_amount_e.setAmount(amount)
|
||||
@ -68,7 +64,7 @@ class RequestList(MyTreeWidget):
|
||||
self.parent.expires_label.setText(expires)
|
||||
self.parent.new_request_button.setEnabled(True)
|
||||
|
||||
def on_update(self):
|
||||
def update(self):
|
||||
self.wallet = self.parent.wallet
|
||||
# hide receive tab if no receive requests available
|
||||
b = len(self.wallet.receive_requests) > 0
|
||||
@ -86,8 +82,9 @@ class RequestList(MyTreeWidget):
|
||||
self.parent.set_receive_address(addr)
|
||||
self.parent.new_request_button.setEnabled(addr != current_address)
|
||||
|
||||
# clear the list and fill it again
|
||||
self.clear()
|
||||
self.model().clear()
|
||||
self.update_headers([_('Date'), _('Address'), '', _('Description'), _('Amount'), _('Status')])
|
||||
self.hideColumn(1) # hide address column
|
||||
for req in self.wallet.get_sorted_requests(self.config):
|
||||
address = req['address']
|
||||
if address not in domain:
|
||||
@ -95,35 +92,40 @@ class RequestList(MyTreeWidget):
|
||||
timestamp = req.get('time', 0)
|
||||
amount = req.get('amount')
|
||||
expiration = req.get('exp', None)
|
||||
message = req.get('memo', '')
|
||||
message = req['memo']
|
||||
date = format_time(timestamp)
|
||||
status = req.get('status')
|
||||
signature = req.get('sig')
|
||||
requestor = req.get('name', '')
|
||||
amount_str = self.parent.format_amount(amount) if amount else ""
|
||||
item = QTreeWidgetItem([date, address, '', message, amount_str, pr_tooltips.get(status,'')])
|
||||
labels = [date, address, '', message, amount_str, pr_tooltips.get(status,'')]
|
||||
items = [QStandardItem(e) for e in labels]
|
||||
self.set_editability(items)
|
||||
if signature is not None:
|
||||
item.setIcon(2, self.icon_cache.get(":icons/seal.png"))
|
||||
item.setToolTip(2, 'signed by '+ requestor)
|
||||
items[2].setIcon(self.icon_cache.get(":icons/seal.png"))
|
||||
items[2].setToolTip('signed by '+ requestor)
|
||||
if status is not PR_UNKNOWN:
|
||||
item.setIcon(6, self.icon_cache.get(pr_icons.get(status)))
|
||||
self.addTopLevelItem(item)
|
||||
|
||||
items[5].setIcon(self.icon_cache.get(pr_icons.get(status)))
|
||||
items[3].setData(address, Qt.UserRole)
|
||||
self.model().insertRow(self.model().rowCount(), items)
|
||||
|
||||
def create_menu(self, position):
|
||||
item = self.itemAt(position)
|
||||
idx = self.indexAt(position)
|
||||
# TODO use siblingAtColumn when min Qt version is >=5.11
|
||||
item = self.model().itemFromIndex(idx.sibling(idx.row(), 1))
|
||||
if not item:
|
||||
return
|
||||
addr = str(item.text(1))
|
||||
addr = item.text()
|
||||
req = self.wallet.receive_requests.get(addr)
|
||||
if req is None:
|
||||
self.update()
|
||||
return
|
||||
column = self.currentColumn()
|
||||
column_title = self.headerItem().text(column)
|
||||
column_data = item.text(column)
|
||||
column = idx.column()
|
||||
column_title = self.model().horizontalHeaderItem(column).text()
|
||||
column_data = item.text()
|
||||
menu = QMenu(self)
|
||||
menu.addAction(_("Copy {}").format(column_title), lambda: self.parent.app.clipboard().setText(column_data))
|
||||
if column != 2:
|
||||
menu.addAction(_("Copy {}").format(column_title), lambda: self.parent.app.clipboard().setText(column_data))
|
||||
menu.addAction(_("Copy URI"), lambda: self.parent.view_and_paste('URI', '', self.parent.get_request_URI(addr)))
|
||||
menu.addAction(_("Save as BIP70 file"), lambda: self.parent.export_payment_request(addr))
|
||||
menu.addAction(_("Delete"), lambda: self.parent.delete_payment_request(addr))
|
||||
|
||||
@ -5,6 +5,7 @@ import platform
|
||||
import queue
|
||||
from functools import partial
|
||||
from typing import NamedTuple, Callable, Optional
|
||||
from abc import abstractmethod
|
||||
|
||||
from PyQt5.QtGui import *
|
||||
from PyQt5.QtCore import *
|
||||
@ -398,20 +399,16 @@ class ElectrumItemDelegate(QStyledItemDelegate):
|
||||
def createEditor(self, parent, option, index):
|
||||
return self.parent().createEditor(parent, option, index)
|
||||
|
||||
class MyTreeWidget(QTreeWidget):
|
||||
class MyTreeView(QTreeView):
|
||||
|
||||
def __init__(self, parent, create_menu, headers, stretch_column=None,
|
||||
editable_columns=None):
|
||||
QTreeWidget.__init__(self, parent)
|
||||
def __init__(self, parent, create_menu, stretch_column=None, editable_columns=None):
|
||||
super().__init__(parent)
|
||||
self.parent = parent
|
||||
self.config = self.parent.config
|
||||
self.stretch_column = stretch_column
|
||||
self.setContextMenuPolicy(Qt.CustomContextMenu)
|
||||
self.customContextMenuRequested.connect(create_menu)
|
||||
self.setUniformRowHeights(True)
|
||||
# extend the syntax for consistency
|
||||
self.addChild = self.addTopLevelItem
|
||||
self.insertChild = self.insertTopLevelItem
|
||||
|
||||
self.icon_cache = IconCache()
|
||||
|
||||
@ -424,127 +421,143 @@ class MyTreeWidget(QTreeWidget):
|
||||
editable_columns = set(editable_columns)
|
||||
self.editable_columns = editable_columns
|
||||
self.setItemDelegate(ElectrumItemDelegate(self))
|
||||
self.itemDoubleClicked.connect(self.on_doubleclick)
|
||||
self.update_headers(headers)
|
||||
self.current_filter = ""
|
||||
|
||||
self.setRootIsDecorated(False) # remove left margin
|
||||
self.toolbar_shown = False
|
||||
|
||||
def update_headers(self, headers):
|
||||
self.setColumnCount(len(headers))
|
||||
self.setHeaderLabels(headers)
|
||||
def set_editability(self, items):
|
||||
for idx, i in enumerate(items):
|
||||
i.setEditable(idx in self.editable_columns)
|
||||
|
||||
def selected_in_column(self, column: int):
|
||||
items = self.selectionModel().selectedIndexes()
|
||||
return list(x for x in items if x.column() == column)
|
||||
|
||||
def current_item_user_role(self, col) -> Optional[QStandardItem]:
|
||||
idx = self.selectionModel().currentIndex()
|
||||
idx = idx.sibling(idx.row(), col)
|
||||
item = self.model().itemFromIndex(idx)
|
||||
if item:
|
||||
return item.data(Qt.UserRole)
|
||||
|
||||
def set_current_idx(self, set_current: QPersistentModelIndex):
|
||||
if set_current:
|
||||
assert isinstance(set_current, QPersistentModelIndex)
|
||||
assert set_current.isValid()
|
||||
self.selectionModel().select(QModelIndex(set_current), QItemSelectionModel.SelectCurrent)
|
||||
|
||||
def update_headers(self, headers, model=None):
|
||||
if model is None:
|
||||
model = self.model()
|
||||
model.setHorizontalHeaderLabels(headers)
|
||||
self.header().setStretchLastSection(False)
|
||||
for col in range(len(headers)):
|
||||
sm = QHeaderView.Stretch if col == self.stretch_column else QHeaderView.ResizeToContents
|
||||
self.header().setSectionResizeMode(col, sm)
|
||||
|
||||
def editItem(self, item, column):
|
||||
if column in self.editable_columns:
|
||||
try:
|
||||
self.editing_itemcol = (item, column, item.text(column))
|
||||
# Calling setFlags causes on_changed events for some reason
|
||||
item.setFlags(item.flags() | Qt.ItemIsEditable)
|
||||
QTreeWidget.editItem(self, item, column)
|
||||
item.setFlags(item.flags() & ~Qt.ItemIsEditable)
|
||||
except RuntimeError:
|
||||
# (item) wrapped C/C++ object has been deleted
|
||||
pass
|
||||
|
||||
def keyPressEvent(self, event):
|
||||
if event.key() in [ Qt.Key_F2, Qt.Key_Return ] and self.editor is None:
|
||||
self.on_activated(self.currentItem(), self.currentColumn())
|
||||
else:
|
||||
QTreeWidget.keyPressEvent(self, event)
|
||||
self.on_activated(self.selectionModel().currentIndex())
|
||||
return
|
||||
super().keyPressEvent(event)
|
||||
|
||||
def permit_edit(self, item, column):
|
||||
return (column in self.editable_columns
|
||||
and self.on_permit_edit(item, column))
|
||||
|
||||
def on_permit_edit(self, item, column):
|
||||
return True
|
||||
|
||||
def on_doubleclick(self, item, column):
|
||||
if self.permit_edit(item, column):
|
||||
self.editItem(item, column)
|
||||
|
||||
def on_activated(self, item, column):
|
||||
def on_activated(self, idx):
|
||||
# on 'enter' we show the menu
|
||||
pt = self.visualItemRect(item).bottomLeft()
|
||||
pt = self.visualRect(idx).bottomLeft()
|
||||
pt.setX(50)
|
||||
self.customContextMenuRequested.emit(pt)
|
||||
|
||||
def createEditor(self, parent, option, index):
|
||||
self.editor = QStyledItemDelegate.createEditor(self.itemDelegate(),
|
||||
parent, option, index)
|
||||
self.editor.editingFinished.connect(self.editing_finished)
|
||||
persistent = QPersistentModelIndex(index)
|
||||
user_role = index.data(Qt.UserRole)
|
||||
assert user_role is not None
|
||||
idx = QModelIndex(persistent)
|
||||
index = self.proxy.mapToSource(idx)
|
||||
item = self.std_model.itemFromIndex(index)
|
||||
prior_text = item.text()
|
||||
def editing_finished():
|
||||
# Long-time QT bug - pressing Enter to finish editing signals
|
||||
# editingFinished twice. If the item changed the sequence is
|
||||
# Enter key: editingFinished, on_change, editingFinished
|
||||
# Mouse: on_change, editingFinished
|
||||
# This mess is the cleanest way to ensure we make the
|
||||
# on_edited callback with the updated item
|
||||
if self.editor is None:
|
||||
return
|
||||
if self.editor.text() == prior_text:
|
||||
self.editor = None # Unchanged - ignore any 2nd call
|
||||
return
|
||||
if item.text() == prior_text:
|
||||
return # Buggy first call on Enter key, item not yet updated
|
||||
if not idx.isValid():
|
||||
return
|
||||
self.on_edited(idx, user_role, self.editor.text())
|
||||
self.editor = None
|
||||
self.editor.editingFinished.connect(editing_finished)
|
||||
return self.editor
|
||||
|
||||
def editing_finished(self):
|
||||
# Long-time QT bug - pressing Enter to finish editing signals
|
||||
# editingFinished twice. If the item changed the sequence is
|
||||
# Enter key: editingFinished, on_change, editingFinished
|
||||
# Mouse: on_change, editingFinished
|
||||
# This mess is the cleanest way to ensure we make the
|
||||
# on_edited callback with the updated item
|
||||
if self.editor:
|
||||
(item, column, prior_text) = self.editing_itemcol
|
||||
if self.editor.text() == prior_text:
|
||||
self.editor = None # Unchanged - ignore any 2nd call
|
||||
elif item.text(column) == prior_text:
|
||||
pass # Buggy first call on Enter key, item not yet updated
|
||||
else:
|
||||
# What we want - the updated item
|
||||
self.on_edited(*self.editing_itemcol)
|
||||
self.editor = None
|
||||
def edit(self, idx, trigger=QAbstractItemView.AllEditTriggers, event=None):
|
||||
"""
|
||||
this is to prevent:
|
||||
edit: editing failed
|
||||
from inside qt
|
||||
"""
|
||||
return super().edit(idx, trigger, event)
|
||||
|
||||
# Now do any pending updates
|
||||
if self.editor is None and self.pending_update:
|
||||
self.pending_update = False
|
||||
self.on_update()
|
||||
|
||||
def on_edited(self, item, column, prior):
|
||||
'''Called only when the text actually changes'''
|
||||
key = item.data(0, Qt.UserRole)
|
||||
text = item.text(column)
|
||||
self.parent.wallet.set_label(key, text)
|
||||
def on_edited(self, idx: QModelIndex, user_role, text):
|
||||
self.parent.wallet.set_label(user_role, text)
|
||||
self.parent.history_list.update_labels()
|
||||
self.parent.update_completions()
|
||||
|
||||
def update(self):
|
||||
# Defer updates if editing
|
||||
if self.editor:
|
||||
self.pending_update = True
|
||||
else:
|
||||
self.setUpdatesEnabled(False)
|
||||
scroll_pos = self.verticalScrollBar().value()
|
||||
self.on_update()
|
||||
self.setUpdatesEnabled(True)
|
||||
# To paint the list before resetting the scroll position
|
||||
self.parent.app.processEvents()
|
||||
self.verticalScrollBar().setValue(scroll_pos)
|
||||
def apply_filter(self):
|
||||
if self.current_filter:
|
||||
self.filter(self.current_filter)
|
||||
|
||||
def on_update(self):
|
||||
@abstractmethod
|
||||
def should_hide(self, row):
|
||||
"""
|
||||
row_num is for self.model(). So if there is a proxy, it is the row number
|
||||
in that!
|
||||
"""
|
||||
pass
|
||||
|
||||
def get_leaves(self, root):
|
||||
child_count = root.childCount()
|
||||
if child_count == 0:
|
||||
yield root
|
||||
for i in range(child_count):
|
||||
item = root.child(i)
|
||||
for x in self.get_leaves(item):
|
||||
yield x
|
||||
def hide_row(self, row_num):
|
||||
"""
|
||||
row_num is for self.model(). So if there is a proxy, it is the row number
|
||||
in that!
|
||||
"""
|
||||
should_hide = self.should_hide(row_num)
|
||||
if not self.current_filter and should_hide is None:
|
||||
# no filters at all, neither date nor search
|
||||
self.setRowHidden(row_num, QModelIndex(), False)
|
||||
return
|
||||
for column in self.filter_columns:
|
||||
if isinstance(self.model(), QSortFilterProxyModel):
|
||||
idx = self.model().mapToSource(self.model().index(row_num, column))
|
||||
item = self.model().sourceModel().itemFromIndex(idx)
|
||||
else:
|
||||
idx = self.model().index(row_num, column)
|
||||
item = self.model().itemFromIndex(idx)
|
||||
txt = item.text().lower()
|
||||
if self.current_filter in txt:
|
||||
# the filter matched, but the date filter might apply
|
||||
self.setRowHidden(row_num, QModelIndex(), bool(should_hide))
|
||||
break
|
||||
else:
|
||||
# we did not find the filter in any columns, show the item
|
||||
self.setRowHidden(row_num, QModelIndex(), True)
|
||||
|
||||
def filter(self, p):
|
||||
columns = self.__class__.filter_columns
|
||||
p = p.lower()
|
||||
self.current_filter = p
|
||||
for item in self.get_leaves(self.invisibleRootItem()):
|
||||
item.setHidden(all([item.text(column).lower().find(p) == -1
|
||||
for column in columns]))
|
||||
self.hide_rows()
|
||||
|
||||
def hide_rows(self):
|
||||
for row in range(self.model().rowCount()):
|
||||
self.hide_row(row)
|
||||
|
||||
def create_toolbar(self, config=None):
|
||||
hbox = QHBoxLayout()
|
||||
@ -790,22 +803,6 @@ def get_parent_main_window(widget):
|
||||
return widget
|
||||
return None
|
||||
|
||||
class SortableTreeWidgetItem(QTreeWidgetItem):
|
||||
DataRole = Qt.UserRole + 100
|
||||
|
||||
def __lt__(self, other):
|
||||
column = self.treeWidget().sortColumn()
|
||||
if None not in [x.data(column, self.DataRole) for x in [self, other]]:
|
||||
# We have set custom data to sort by
|
||||
return self.data(column, self.DataRole) < other.data(column, self.DataRole)
|
||||
try:
|
||||
# Is the value something numeric?
|
||||
return float(self.text(column)) < float(other.text(column))
|
||||
except ValueError:
|
||||
# If not, we will just do string comparison
|
||||
return self.text(column) < other.text(column)
|
||||
|
||||
|
||||
class IconCache:
|
||||
|
||||
def __init__(self):
|
||||
@ -821,6 +818,21 @@ def get_default_language():
|
||||
name = QLocale.system().name()
|
||||
return name if name in languages else 'en_UK'
|
||||
|
||||
class FromList(QTreeWidget):
|
||||
def __init__(self, parent, create_menu):
|
||||
super().__init__(parent)
|
||||
self.setHeaderHidden(True)
|
||||
self.setMaximumHeight(300)
|
||||
self.setContextMenuPolicy(Qt.CustomContextMenu)
|
||||
self.customContextMenuRequested.connect(create_menu)
|
||||
self.setUniformRowHeights(True)
|
||||
# remove left margin
|
||||
self.setRootIsDecorated(False)
|
||||
self.setColumnCount(2)
|
||||
self.header().setStretchLastSection(False)
|
||||
sm = QHeaderView.ResizeToContents
|
||||
self.header().setSectionResizeMode(0, sm)
|
||||
self.header().setSectionResizeMode(1, sm)
|
||||
|
||||
if __name__ == "__main__":
|
||||
app = QApplication([])
|
||||
|
||||
@ -23,49 +23,60 @@
|
||||
# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
||||
# SOFTWARE.
|
||||
|
||||
from typing import Optional, List
|
||||
|
||||
from electrum.i18n import _
|
||||
|
||||
from .util import *
|
||||
|
||||
|
||||
class UTXOList(MyTreeWidget):
|
||||
filter_columns = [0, 2] # Address, Label
|
||||
class UTXOList(MyTreeView):
|
||||
filter_columns = [0, 1] # Address, Label
|
||||
|
||||
def __init__(self, parent=None):
|
||||
MyTreeWidget.__init__(self, parent, self.create_menu, [ _('Address'), _('Label'), _('Amount'), _('Height'), _('Output point')], 1)
|
||||
super().__init__(parent, self.create_menu, 1)
|
||||
self.setModel(QStandardItemModel(self))
|
||||
self.setSelectionMode(QAbstractItemView.ExtendedSelection)
|
||||
self.setSortingEnabled(True)
|
||||
self.update()
|
||||
|
||||
def get_name(self, x):
|
||||
return x.get('prevout_hash') + ":%d"%x.get('prevout_n')
|
||||
|
||||
def on_update(self):
|
||||
def update(self):
|
||||
self.wallet = self.parent.wallet
|
||||
item = self.currentItem()
|
||||
self.clear()
|
||||
self.utxos = self.wallet.get_utxos()
|
||||
for x in self.utxos:
|
||||
utxos = self.wallet.get_utxos()
|
||||
self.utxo_dict = {}
|
||||
self.model().clear()
|
||||
self.update_headers([ _('Address'), _('Label'), _('Amount'), _('Height'), _('Output point')])
|
||||
for idx, x in enumerate(utxos):
|
||||
address = x.get('address')
|
||||
height = x.get('height')
|
||||
name = self.get_name(x)
|
||||
name = x.get('prevout_hash') + ":%d"%x.get('prevout_n')
|
||||
self.utxo_dict[name] = x
|
||||
label = self.wallet.get_label(x.get('prevout_hash'))
|
||||
amount = self.parent.format_amount(x['value'], whitespaces=True)
|
||||
utxo_item = SortableTreeWidgetItem([address, label, amount, '%d'%height, name[0:10] + '...' + name[-2:]])
|
||||
utxo_item.setFont(0, QFont(MONOSPACE_FONT))
|
||||
utxo_item.setFont(2, QFont(MONOSPACE_FONT))
|
||||
utxo_item.setFont(4, QFont(MONOSPACE_FONT))
|
||||
utxo_item.setData(0, Qt.UserRole, name)
|
||||
labels = [address, label, amount, '%d'%height, name[0:10] + '...' + name[-2:]]
|
||||
utxo_item = [QStandardItem(x) for x in labels]
|
||||
self.set_editability(utxo_item)
|
||||
utxo_item[0].setFont(QFont(MONOSPACE_FONT))
|
||||
utxo_item[2].setFont(QFont(MONOSPACE_FONT))
|
||||
utxo_item[4].setFont(QFont(MONOSPACE_FONT))
|
||||
utxo_item[0].setData(name, Qt.UserRole)
|
||||
if self.wallet.is_frozen(address):
|
||||
utxo_item.setBackground(0, ColorScheme.BLUE.as_color(True))
|
||||
self.addChild(utxo_item)
|
||||
utxo_item[0].setBackground(ColorScheme.BLUE.as_color(True))
|
||||
self.model().insertRow(idx, utxo_item)
|
||||
|
||||
def selected_column_0_user_roles(self) -> Optional[List[str]]:
|
||||
if not self.model():
|
||||
return None
|
||||
items = self.selected_in_column(0)
|
||||
if not items:
|
||||
return None
|
||||
return [x.data(Qt.UserRole) for x in items]
|
||||
|
||||
def create_menu(self, position):
|
||||
selected = [x.data(0, Qt.UserRole) for x in self.selectedItems()]
|
||||
selected = self.selected_column_0_user_roles()
|
||||
if not selected:
|
||||
return
|
||||
menu = QMenu()
|
||||
coins = filter(lambda x: self.get_name(x) in selected, self.utxos)
|
||||
|
||||
coins = (self.utxo_dict[name] for name in selected)
|
||||
menu.addAction(_("Spend"), lambda: self.parent.spend_coins(coins))
|
||||
if len(selected) == 1:
|
||||
txid = selected[0].split(':')[0]
|
||||
@ -75,7 +86,3 @@ class UTXOList(MyTreeWidget):
|
||||
menu.addAction(_("Details"), lambda: self.parent.show_transaction(tx, label))
|
||||
|
||||
menu.exec_(self.viewport().mapToGlobal(position))
|
||||
|
||||
def on_permit_edit(self, item, column):
|
||||
# disable editing fields in this tab (labels)
|
||||
return False
|
||||
|
||||
Loading…
Reference in New Issue
Block a user