from electrum import util, bitcoin, commands, Interface, Wallet
from electrum import SimpleConfig, Wallet, WalletStorage
-
from electrum import bmp, pyqrnative
-from amountedit import AmountEdit
+from amountedit import AmountEdit, BTCAmountEdit, MyLineEdit
from network_dialog import NetworkDialog
-from qrcodewidget import QRCodeWidget
+from qrcodewidget import QRCodeWidget, QRDialog
from decimal import Decimal
else:
MONOSPACE_FONT = 'monospace'
+
+
+# status of payment requests
+PR_UNPAID = 0
+PR_EXPIRED = 1
+PR_SENT = 2 # sent but not propagated
+PR_PAID = 3 # send and propagated
+PR_ERROR = 4 # could not parse
+
+
from electrum import ELECTRUM_VERSION
import re
from util import *
-
-
+def format_status(x):
+ if x == PR_UNPAID:
+ return _('Unpaid')
+ elif x == PR_PAID:
+ return _('Paid')
+ elif x == PR_EXPIRED:
+ return _('Expired')
class StatusBarButton(QPushButton):
self.decimal_point = config.get('decimal_point', 5)
self.num_zeros = int(config.get('num_zeros',0))
+ self.invoices = {}
set_language(config.get('language'))
tabs.addTab(self.create_send_tab(), _('Send') )
tabs.addTab(self.create_receive_tab(), _('Receive') )
tabs.addTab(self.create_contacts_tab(), _('Contacts') )
+ tabs.addTab(self.create_invoices_tab(), _('Invoices') )
tabs.addTab(self.create_console_tab(), _('Console') )
tabs.setMinimumSize(600, 400)
tabs.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
self.console.showMessage(self.network.banner)
self.wallet = None
-
+ self.payment_request = None
def update_account_selector(self):
# account selector
self.wallet = wallet
self.update_wallet_format()
+ self.invoices = self.wallet.storage.get('invoices', {})
self.accounts_expanded = self.wallet.storage.get('accounts_expanded',{})
self.current_account = self.wallet.storage.get("current_account", None)
title = 'Electrum ' + self.wallet.electrum_version + ' - ' + self.wallet.storage.path
tools_menu.addAction(_("&Plugins"), self.plugins_dialog)
tools_menu.addSeparator()
tools_menu.addAction(_("&Sign/verify message"), self.sign_verify_message)
- #tools_menu.addAction(_("&Encrypt/decrypt message"), self.encrypt_message)
+ tools_menu.addAction(_("&Encrypt/decrypt message"), self.encrypt_message)
tools_menu.addSeparator()
csv_transaction_menu = tools_menu.addMenu(_("&Create transaction"))
raw_transaction_menu.addAction(_("&From file"), self.do_process_from_file)
raw_transaction_menu.addAction(_("&From text"), self.do_process_from_text)
raw_transaction_menu.addAction(_("&From the blockchain"), self.do_process_from_txid)
+ self.raw_transaction_menu = raw_transaction_menu
help_menu = menubar.addMenu(_("&Help"))
help_menu.addAction(_("&About"), self.show_about)
self.update_receive_tab()
self.update_contacts_tab()
self.update_completions()
+ self.update_invoices_tab()
def create_history_tab(self):
def create_send_tab(self):
w = QWidget()
- grid = QGridLayout(w)
+ self.send_grid = grid = QGridLayout(w)
grid.setSpacing(8)
grid.setColumnMinimumWidth(3,300)
grid.setColumnStretch(5,1)
grid.setRowStretch(8, 1)
from paytoedit import PayToEdit
- self.payto_e = PayToEdit()
+ self.amount_e = BTCAmountEdit(self.get_decimal_point)
+ self.payto_e = PayToEdit(self)
self.payto_help = HelpButton(_('Recipient of the funds.') + '\n\n' + _('You may enter a Bitcoin address, a label from your list of contacts (a list of completions will be proposed), or an alias (email-like address that forwards to a Bitcoin address)'))
grid.addWidget(QLabel(_('Pay to')), 1, 0)
grid.addWidget(self.payto_e, 1, 1, 1, 3)
self.payto_e.setCompleter(completer)
completer.setModel(self.completions)
- self.message_e = QLineEdit()
+ self.message_e = MyLineEdit()
self.message_help = HelpButton(_('Description of the transaction (not mandatory).') + '\n\n' + _('The description is not sent to the recipient of the funds. It is stored in your wallet file, and displayed in the \'History\' tab.'))
grid.addWidget(QLabel(_('Description')), 2, 0)
grid.addWidget(self.message_e, 2, 1, 1, 3)
self.from_label = QLabel(_('From'))
grid.addWidget(self.from_label, 3, 0)
- self.from_list = QTreeWidget(self)
+ self.from_list = MyTreeWidget(self)
self.from_list.setColumnCount(2)
self.from_list.setColumnWidth(0, 350)
self.from_list.setColumnWidth(1, 50)
- self.from_list.setHeaderHidden (True)
+ self.from_list.setHeaderHidden(True)
self.from_list.setMaximumHeight(80)
+ self.from_list.setContextMenuPolicy(Qt.CustomContextMenu)
+ self.from_list.customContextMenuRequested.connect(self.from_list_menu)
grid.addWidget(self.from_list, 3, 1, 1, 3)
self.set_pay_from([])
- self.amount_e = AmountEdit(self.get_decimal_point)
self.amount_help = HelpButton(_('Amount to be sent.') + '\n\n' \
+ _('The amount will be displayed in red if you do not have enough funds in your wallet. Note that if you have frozen some of your addresses, the available funds will be lower than your total balance.') \
+ '\n\n' + _('Keyboard shortcut: type "!" to send all your coins.'))
grid.addWidget(self.amount_e, 4, 1, 1, 2)
grid.addWidget(self.amount_help, 4, 3)
- self.fee_e = AmountEdit(self.get_decimal_point)
+ self.fee_e = BTCAmountEdit(self.get_decimal_point)
grid.addWidget(QLabel(_('Fee')), 5, 0)
grid.addWidget(self.fee_e, 5, 1, 1, 2)
grid.addWidget(HelpButton(
+ _('The amount of fee can be decided freely by the sender. However, transactions with low fees take more time to be processed.') + '\n\n'\
+ _('A suggested fee is automatically added to this field. You may override it. The suggested fee increases with the size of the transaction.')), 5, 3)
- run_hook('exchange_rate_button', grid)
-
self.send_button = EnterButton(_("Send"), self.do_send)
grid.addWidget(self.send_button, 6, 1)
self.payto_sig = QLabel('')
grid.addWidget(self.payto_sig, 7, 0, 1, 4)
- QShortcut(QKeySequence("Up"), w, w.focusPreviousChild)
- QShortcut(QKeySequence("Down"), w, w.focusNextChild)
+ #QShortcut(QKeySequence("Up"), w, w.focusPreviousChild)
+ #QShortcut(QKeySequence("Down"), w, w.focusNextChild)
w.setLayout(grid)
def entry_changed( is_fee ):
self.amount_e.is_shortcut = False
sendable = self.get_sendable_balance()
# there is only one output because we are completely spending inputs
- inputs, total, fee = self.wallet.choose_tx_inputs( sendable, 0, 1, self.get_payment_sources())
+ inputs, total, fee = self.wallet.choose_tx_inputs( sendable, 0, 1, coins = self.get_coins())
fee = self.wallet.estimated_fee(inputs, 1)
amount = total - fee
- self.amount_e.setText( self.format_amount(amount) )
- self.fee_e.setText( self.format_amount( fee ) )
+ self.amount_e.setAmount(amount)
+ self.fee_e.setAmount(fee)
return
amount = self.amount_e.get_amount()
if amount is None:
return
# assume that there will be 2 outputs (one for change)
- inputs, total, fee = self.wallet.choose_tx_inputs(amount, fee, 2, self.get_payment_sources())
+ inputs, total, fee = self.wallet.choose_tx_inputs(amount, fee, 2, coins = self.get_coins())
if not is_fee:
- self.fee_e.setText( self.format_amount( fee ) )
+ self.fee_e.setAmount(fee)
if inputs:
palette = QPalette()
palette.setColor(self.amount_e.foregroundRole(), QColor('black'))
run_hook('create_send_tab', grid)
return w
+ def from_list_delete(self, item):
+ i = self.from_list.indexOfTopLevelItem(item)
+ self.pay_from.pop(i)
+ self.redraw_from_list()
+
+ def from_list_menu(self, position):
+ item = self.from_list.itemAt(position)
+ menu = QMenu()
+ menu.addAction(_("Remove"), lambda: self.from_list_delete(item))
+ menu.exec_(self.from_list.viewport().mapToGlobal(position))
- def set_pay_from(self, l):
- self.pay_from = l
+ def set_pay_from(self, domain = None):
+ self.pay_from = [] if domain == [] else self.wallet.get_unspent_coins(domain)
+ self.redraw_from_list()
+
+ def redraw_from_list(self):
self.from_list.clear()
self.from_label.setHidden(len(self.pay_from) == 0)
self.from_list.setHidden(len(self.pay_from) == 0)
- for addr in self.pay_from:
- c, u = self.wallet.get_addr_balance(addr)
- balance = self.format_amount(c + u)
- self.from_list.addTopLevelItem(QTreeWidgetItem( [addr, balance] ))
+ def format(x):
+ h = x.get('prevout_hash')
+ return h[0:8] + '...' + h[-8:] + ":%d"%x.get('prevout_n') + u'\t' + "%s"%x.get('address')
+
+ for item in self.pay_from:
+ self.from_list.addTopLevelItem(QTreeWidgetItem( [format(item), self.format_amount(item['value']) ]))
def update_completions(self):
l = []
return lambda s, *args: s.do_protect(func, args)
- def do_send(self):
- label = unicode( self.message_e.text() )
+ def read_send_tab(self):
+
+ if self.payment_request and self.payment_request.has_expired():
+ QMessageBox.warning(self, _('Error'), _('Payment request has expired'), _('OK'))
+ return
- if self.gui_object.payment_request:
- outputs = self.gui_object.payment_request.outputs
- amount = self.gui_object.payment_request.get_amount()
+ label = unicode( self.message_e.text() )
+ if self.payment_request:
+ outputs = self.payment_request.get_outputs()
else:
- r = unicode( self.payto_e.text() )
- r = r.strip()
-
- # label or alias, with address in brackets
- m = re.match('(.*?)\s*\<([1-9A-HJ-NP-Za-km-z]{26,})\>', r)
- to_address = m.group(2) if m else r
- if not is_valid(to_address):
- QMessageBox.warning(self, _('Error'), _('Invalid Bitcoin Address') + ':\n' + to_address, _('OK'))
+ outputs = self.payto_e.get_outputs()
+
+ if not outputs:
+ QMessageBox.warning(self, _('Error'), _('No outputs'), _('OK'))
+ return
+
+ for addr, x in outputs:
+ if addr is None or not bitcoin.is_address(addr):
+ QMessageBox.warning(self, _('Error'), _('Invalid Bitcoin Address'), _('OK'))
return
-
- try:
- amount = self.amount_e.get_amount()
- except Exception:
+ if x is None:
QMessageBox.warning(self, _('Error'), _('Invalid Amount'), _('OK'))
return
- outputs = [(to_address, amount)]
+ amount = sum(map(lambda x:x[1], outputs))
- try:
- fee = self.fee_e.get_amount()
- except Exception:
+ fee = self.fee_e.get_amount()
+ if fee is None:
QMessageBox.warning(self, _('Error'), _('Invalid Fee'), _('OK'))
return
confirm_amount = self.config.get('confirm_amount', 100000000)
if amount >= confirm_amount:
- if not self.question(_("send %(amount)s to %(address)s?")%{ 'amount' : self.format_amount(amount) + ' '+ self.base_unit(), 'address' : to_address}):
+ o = '\n'.join(map(lambda x:x[0], outputs))
+ if not self.question(_("send %(amount)s to %(address)s?")%{ 'amount' : self.format_amount(amount) + ' '+ self.base_unit(), 'address' : o}):
return
confirm_fee = self.config.get('confirm_fee', 100000)
if not self.question(_("The fee for this transaction seems unusually high.\nAre you really sure you want to pay %(fee)s in fees?")%{ 'fee' : self.format_amount(fee) + ' '+ self.base_unit()}):
return
- self.send_tx(outputs, fee, label)
+ coins = self.get_coins()
+ return outputs, fee, label, coins
+ def do_send(self):
+ r = self.read_send_tab()
+ if not r:
+ return
+ outputs, fee, label, coins = r
+ self.send_tx(outputs, fee, label, coins)
+
@protected
- def send_tx(self, outputs, fee, label, password):
+ def send_tx(self, outputs, fee, label, coins, password):
self.send_button.setDisabled(True)
# first, create an unsigned tx
- domain = self.get_payment_sources()
try:
- tx = self.wallet.make_unsigned_transaction(outputs, fee, None, domain)
+ tx = self.wallet.make_unsigned_transaction(outputs, fee, None, coins = coins)
tx.error = None
except Exception as e:
traceback.print_exc(file=sys.stdout)
if label:
self.wallet.set_label(tx.hash(), label)
- if not self.gui_object.payment_request:
- if not tx.is_complete() or self.config.get('show_before_broadcast'):
- self.show_transaction(tx)
- self.do_clear()
- self.send_button.setDisabled(False)
- return
+ if not tx.is_complete() or self.config.get('show_before_broadcast'):
+ self.show_transaction(tx)
+ self.do_clear()
+ self.send_button.setDisabled(False)
+ return
self.broadcast_transaction(tx)
def broadcast_transaction(self, tx):
def broadcast_thread():
- if self.gui_object.payment_request:
- refund_address = self.wallet.addresses()[0]
- status, msg = self.gui_object.payment_request.send_ack(str(tx), refund_address)
- self.gui_object.payment_request = None
- else:
- status, msg = self.wallet.sendtx(tx)
+ pr = self.payment_request
+ if pr is None:
+ return self.wallet.sendtx(tx)
+
+ if pr.has_expired():
+ self.payment_request = None
+ return False, _("Payment request has expired")
+
+ status, msg = self.wallet.sendtx(tx)
+ if not status:
+ return False, msg
+
+ self.invoices[pr.get_id()] = (pr.get_domain(), pr.get_memo(), pr.get_amount(), pr.get_expiration_date(), PR_PAID, tx.hash())
+ self.wallet.storage.put('invoices', self.invoices)
+ self.update_invoices_tab()
+ self.payment_request = None
+ refund_address = self.wallet.addresses()[0]
+ ack_status, ack_msg = pr.send_ack(str(tx), refund_address)
+ if ack_status:
+ msg = ack_msg
+
return status, msg
def broadcast_done(status, msg):
def prepare_for_payment_request(self):
- style = "QWidget { background-color:none;border:none;}"
self.tabs.setCurrentIndex(1)
+ self.payto_e.is_pr = True
for e in [self.payto_e, self.amount_e, self.message_e]:
- e.setReadOnly(True)
- e.setStyleSheet(style)
+ e.setFrozen(True)
for h in [self.payto_help, self.amount_help, self.message_help]:
h.hide()
self.payto_e.setText(_("please wait..."))
return True
def payment_request_ok(self):
- self.payto_e.setText(self.gui_object.payment_request.domain)
- self.amount_e.setText(self.format_amount(self.gui_object.payment_request.get_amount()))
- self.message_e.setText(self.gui_object.payment_request.memo)
+ pr = self.payment_request
+ pr_id = pr.get_id()
+ if pr_id not in self.invoices:
+ self.invoices[pr_id] = (pr.get_domain(), pr.get_memo(), pr.get_amount(), pr.get_expiration_date(), PR_UNPAID, None)
+ self.wallet.storage.put('invoices', self.invoices)
+ self.update_invoices_tab()
+ else:
+ print_error('invoice already in list')
+
+ status = self.invoices[pr_id][4]
+ if status == PR_PAID:
+ self.do_clear()
+ self.show_message("invoice already paid")
+ self.payment_request = None
+ return
+
+ self.payto_help.show()
+ self.payto_help.set_alt(lambda: self.show_pr_details(pr))
+
+ if not pr.has_expired():
+ self.payto_e.setGreen()
+ else:
+ self.payto_e.setExpired()
+
+ self.payto_e.setText(pr.domain)
+ self.amount_e.setText(self.format_amount(pr.get_amount()))
+ self.message_e.setText(pr.get_memo())
def payment_request_error(self):
self.do_clear()
- self.show_message(self.gui_object.payment_request.error)
+ self.show_message(self.payment_request.error)
+ self.payment_request = None
+ def pay_from_URI(self,URI):
+ if not URI:
+ return
+ address, amount, label, message, request_url = util.parse_URI(URI)
+ try:
+ address, amount, label, message, request_url = util.parse_URI(URI)
+ except Exception as e:
+ QMessageBox.warning(self, _('Error'), _('Invalid bitcoin URI:') + '\n' + str(e), _('OK'))
+ return
- def set_send(self, address, amount, label, message):
+ self.tabs.setCurrentIndex(1)
- if label and self.wallet.labels.get(address) != label:
- if self.question('Give label "%s" to address %s ?'%(label,address)):
- if address not in self.wallet.addressbook and not self.wallet.is_mine(address):
- self.wallet.addressbook.append(address)
- self.wallet.set_label(address, label)
+ if not request_url:
+ if label:
+ if self.wallet.labels.get(address) != label:
+ if self.question(_('Save label "%s" for address %s ?'%(label,address))):
+ if address not in self.wallet.addressbook and not self.wallet.is_mine(address):
+ self.wallet.addressbook.append(address)
+ self.wallet.set_label(address, label)
+ else:
+ label = self.wallet.labels.get(address)
+ if address:
+ self.payto_e.setText(label + ' <'+ address +'>' if label else address)
+ if message:
+ self.message_e.setText(message)
+ if amount:
+ self.amount_e.setAmount(amount)
+ return
- self.tabs.setCurrentIndex(1)
- label = self.wallet.labels.get(address)
- m_addr = label + ' <'+ address +'>' if label else address
- self.payto_e.setText(m_addr)
+ from electrum import paymentrequest
+ def payment_request():
+ self.payment_request = paymentrequest.PaymentRequest(self.config)
+ self.payment_request.read(request_url)
+ if self.payment_request.verify():
+ self.emit(SIGNAL('payment_request_ok'))
+ else:
+ self.emit(SIGNAL('payment_request_error'))
+
+ self.pr_thread = threading.Thread(target=payment_request).start()
+ self.prepare_for_payment_request()
- self.message_e.setText(message)
- if amount:
- self.amount_e.setText(amount)
def do_clear(self):
+ self.payto_e.is_pr = False
self.payto_sig.setVisible(False)
for e in [self.payto_e, self.message_e, self.amount_e, self.fee_e]:
e.setText('')
- self.set_frozen(e,False)
- e.setStyleSheet("")
+ e.setFrozen(False)
+
for h in [self.payto_help, self.amount_help, self.message_help]:
h.show()
+ self.payto_help.set_alt(None)
self.set_pay_from([])
self.update_status()
- def set_frozen(self,entry,frozen):
- if frozen:
- entry.setReadOnly(True)
- entry.setFrame(False)
- palette = QPalette()
- palette.setColor(entry.backgroundRole(), QColor('lightgray'))
- entry.setPalette(palette)
- else:
- entry.setReadOnly(False)
- entry.setFrame(True)
- palette = QPalette()
- palette.setColor(entry.backgroundRole(), QColor('white'))
- entry.setPalette(palette)
def set_addrs_frozen(self,addrs,freeze):
buttons = QWidget()
vbox.addWidget(buttons)
- hbox = QHBoxLayout()
- hbox.setMargin(0)
- hbox.setSpacing(0)
- buttons.setLayout(hbox)
-
- return l,w,hbox
+ return l, w
def create_receive_tab(self):
- l,w,hbox = self.create_list_tab([ _('Address'), _('Label'), _('Balance'), _('Tx')])
+ l, w = self.create_list_tab([ _('Address'), _('Label'), _('Balance'), _('Tx')])
+ for i,width in enumerate(self.column_widths['receive']):
+ l.setColumnWidth(i, width)
l.setContextMenuPolicy(Qt.CustomContextMenu)
l.customContextMenuRequested.connect(self.create_receive_menu)
l.setSelectionMode(QAbstractItemView.ExtendedSelection)
self.connect(l, SIGNAL('itemChanged(QTreeWidgetItem*, int)'), lambda a,b: self.address_label_changed(a,b,l,0,1))
self.connect(l, SIGNAL('currentItemChanged(QTreeWidgetItem*, QTreeWidgetItem*)'), lambda a,b: self.current_item_changed(a))
self.receive_list = l
- self.receive_buttons_hbox = hbox
- hbox.addStretch(1)
return w
def create_contacts_tab(self):
- l,w,hbox = self.create_list_tab([_('Address'), _('Label'), _('Tx')])
+ l, w = self.create_list_tab([_('Address'), _('Label'), _('Tx')])
l.setContextMenuPolicy(Qt.CustomContextMenu)
l.customContextMenuRequested.connect(self.create_contact_menu)
for i,width in enumerate(self.column_widths['contacts']):
l.setColumnWidth(i, width)
-
self.connect(l, SIGNAL('itemDoubleClicked(QTreeWidgetItem*, int)'), lambda a, b: self.address_label_clicked(a,b,l,0,1))
self.connect(l, SIGNAL('itemChanged(QTreeWidgetItem*, int)'), lambda a,b: self.address_label_changed(a,b,l,0,1))
self.contacts_list = l
- self.contacts_buttons_hbox = hbox
- hbox.addStretch(1)
return w
+ def create_invoices_tab(self):
+ l, w = self.create_list_tab([_('Requestor'), _('Memo'),_('Amount'), _('Status')])
+ h = l.header()
+ h.setStretchLastSection(False)
+ h.setResizeMode(1, QHeaderView.Stretch)
+ l.setContextMenuPolicy(Qt.CustomContextMenu)
+ l.customContextMenuRequested.connect(self.create_invoice_menu)
+ self.invoices_list = l
+ return w
+
+ def update_invoices_tab(self):
+ invoices = self.wallet.storage.get('invoices', {})
+ l = self.invoices_list
+ l.clear()
+ for key, value in invoices.items():
+ try:
+ domain, memo, amount, expiration_date, status, tx_hash = value
+ except:
+ invoices.pop(key)
+ continue
+ if status == PR_UNPAID and expiration_date and expiration_date < time.time():
+ status = PR_EXPIRED
+ item = QTreeWidgetItem( [ domain, memo, self.format_amount(amount), format_status(status)] )
+ l.addTopLevelItem(item)
+
+ l.setCurrentItem(l.topLevelItem(0))
+
+
+
def delete_imported_key(self, addr):
if self.question(_("Do you want to remove")+" %s "%addr +_("from your wallet?")):
self.wallet.delete_imported_key(addr)
if not self.wallet.is_watching_only():
menu.addAction(_("Private key"), lambda: self.show_private_key(addr))
menu.addAction(_("Sign/verify message"), lambda: self.sign_verify_message(addr))
- #menu.addAction(_("Encrypt/decrypt message"), lambda: self.encrypt_message(addr))
+ menu.addAction(_("Encrypt/decrypt message"), lambda: self.encrypt_message(addr))
if self.wallet.is_imported(addr):
menu.addAction(_("Remove from wallet"), lambda: self.delete_imported_key(addr))
def get_sendable_balance(self):
- return sum(sum(self.wallet.get_addr_balance(a)) for a in self.get_payment_sources())
+ return sum(map(lambda x:x['value'], self.get_coins()))
- def get_payment_sources(self):
+ def get_coins(self):
if self.pay_from:
return self.pay_from
else:
- return self.wallet.get_account_addresses(self.current_account)
+ domain = self.wallet.get_account_addresses(self.current_account)
+ for i in self.wallet.frozen_addresses:
+ if i in domain: domain.remove(i)
+ return self.wallet.get_unspent_coins(domain)
def send_from_addresses(self, addrs):
run_hook('create_contact_menu', menu, item)
menu.exec_(self.contacts_list.viewport().mapToGlobal(position))
+ def delete_invoice(self, key):
+ self.invoices.pop(key)
+ self.wallet.storage.put('invoices', self.invoices)
+ self.update_invoices_tab()
+
+ def show_invoice(self, key):
+ from electrum.paymentrequest import PaymentRequest
+ domain, memo, value, expiration, status, tx_hash = self.invoices[key]
+ pr = PaymentRequest(self.config)
+ pr.read_file(key)
+ pr.domain = domain
+ pr.verify()
+ self.show_pr_details(pr)
+
+ def show_pr_details(self, pr):
+ msg = 'Domain: ' + pr.domain
+ msg += '\nStatus: ' + pr.get_status()
+ msg += '\nMemo: ' + pr.get_memo()
+ msg += '\nPayment URL: ' + pr.payment_url
+ msg += '\n\nOutputs:\n' + '\n'.join(map(lambda x: x[0] + ' ' + self.format_amount(x[1])+ self.base_unit(), pr.get_outputs()))
+ QMessageBox.information(self, 'Invoice', msg , 'OK')
+
+ def do_pay_invoice(self, key):
+ from electrum.paymentrequest import PaymentRequest
+ domain, memo, value, status, tx_hash = self.invoices[key]
+ pr = PaymentRequest(self.config)
+ pr.read_file(key)
+ pr.domain = domain
+ self.payment_request = pr
+ self.prepare_for_payment_request()
+ if pr.verify():
+ self.payment_request_ok()
+ else:
+ self.payment_request_error()
+
+
+ def create_invoice_menu(self, position):
+ item = self.invoices_list.itemAt(position)
+ if not item:
+ return
+ k = self.invoices_list.indexOfTopLevelItem(item)
+ key = self.invoices.keys()[k]
+ domain, memo, value, expiration, status, tx_hash = self.invoices[key]
+ menu = QMenu()
+ menu.addAction(_("Details"), lambda: self.show_invoice(key))
+ if status == PR_UNPAID:
+ menu.addAction(_("Pay Now"), lambda: self.do_pay_invoice(key))
+ menu.addAction(_("Delete"), lambda: self.delete_invoice(key))
+ menu.exec_(self.invoices_list.viewport().mapToGlobal(position))
+
def update_receive_item(self, item):
item.setFont(0, QFont(MONOSPACE_FONT))
l.insertChild = l.insertTopLevelItem
l.clear()
- for i,width in enumerate(self.column_widths['receive']):
- l.setColumnWidth(i, width)
accounts = self.wallet.get_accounts()
if self.current_account is None:
def show_qrcode(self, data, title = _("QR code")):
- if not data: return
- d = QDialog(self)
- d.setModal(1)
- d.setWindowTitle(title)
- d.setMinimumSize(270, 300)
- vbox = QVBoxLayout()
- qrw = QRCodeWidget(data)
- vbox.addWidget(qrw, 1)
- vbox.addWidget(QLabel(data), 0, Qt.AlignHCenter)
- hbox = QHBoxLayout()
- hbox.addStretch(1)
-
- filename = os.path.join(self.config.path, "qrcode.bmp")
-
- def print_qr():
- bmp.save_qrcode(qrw.qr, filename)
- QMessageBox.information(None, _('Message'), _("QR code saved to file") + " " + filename, _('OK'))
-
- def copy_to_clipboard():
- bmp.save_qrcode(qrw.qr, filename)
- self.app.clipboard().setImage(QImage(filename))
- QMessageBox.information(None, _('Message'), _("QR code saved to clipboard"), _('OK'))
-
- b = QPushButton(_("Copy"))
- hbox.addWidget(b)
- b.clicked.connect(copy_to_clipboard)
-
- b = QPushButton(_("Save"))
- hbox.addWidget(b)
- b.clicked.connect(print_qr)
-
- b = QPushButton(_("Close"))
- hbox.addWidget(b)
- b.clicked.connect(d.accept)
- b.setDefault(True)
-
- vbox.addLayout(hbox)
- d.setLayout(vbox)
+ if not data:
+ return
+ d = QRDialog(data, self, title)
d.exec_()
fee_label = QLabel(_('Transaction fee') + ':')
grid.addWidget(fee_label, 2, 0)
- fee_e = AmountEdit(self.get_decimal_point)
- fee_e.setText(self.format_amount(self.wallet.fee).strip())
+ fee_e = BTCAmountEdit(self.get_decimal_point)
+ fee_e.setAmount(self.wallet.fee)
grid.addWidget(fee_e, 2, 1)
- msg = _('Fee per kilobyte of transaction.') + ' ' \
- + _('Recommended value') + ': ' + self.format_amount(20000)
+ msg = _('Fee per kilobyte of transaction.') + '\n' \
+ + _('Recommended value') + ': ' + self.format_amount(10000) + ' ' + self.base_unit()
grid.addWidget(HelpButton(msg), 2, 2)
if not self.config.is_modifiable('fee_per_kb'):
for w in [fee_e, fee_label]: w.setEnabled(False)
# run the dialog
if not d.exec_(): return
- try:
- fee = self.fee_e.get_amount()
- except Exception:
+ fee = fee_e.get_amount()
+ if fee is None:
QMessageBox.warning(self, _('Error'), _('Invalid value') +': %s'%fee, _('OK'))
return
git://git.novaco.in / electrum-nvc.git / blobdiff