from electrum.i18n import _, set_language
from electrum.util import print_error, print_msg
import os.path, json, ast, traceback
+import webbrowser
import shutil
import StringIO
from util import *
-
+
default_column_widths = { "history":[40,140,350,140], "contacts":[350,330], "receive": [370,200,130] }
class ElectrumWindow(QMainWindow):
- def changeEvent(self, event):
- flags = self.windowFlags();
- if event and event.type() == QtCore.QEvent.WindowStateChange:
- if self.windowState() & QtCore.Qt.WindowMinimized:
- self.build_menu(True)
- # The only way to toggle the icon in the window managers taskbar is to use the Qt.Tooltip flag
- # The problem is that it somehow creates an (in)visible window that will stay active and prevent
- # Electrum from closing.
- # As for now I have no clue how to implement a proper 'hide to tray' functionality.
- # self.setWindowFlags(flags & ~Qt.ToolTip)
- elif event.oldState() & QtCore.Qt.WindowMinimized:
- self.build_menu(False)
- #self.setWindowFlags(flags | Qt.ToolTip)
-
- def build_menu(self, is_hidden = False):
- m = QMenu()
- if self.isMinimized():
- m.addAction(_("Show"), self.showNormal)
- else:
- m.addAction(_("Hide"), self.showMinimized)
-
- m.addSeparator()
- m.addAction(_("Exit Electrum"), self.close)
- self.tray.setContextMenu(m)
- def tray_activated(self, reason):
- if reason == QSystemTrayIcon.DoubleClick:
- self.showNormal()
- def showNormal(self):
- self.setWindowState(self.windowState() & ~QtCore.Qt.WindowMinimized | QtCore.Qt.WindowActive)
- def __init__(self, config, network):
+ def __init__(self, config, network, gui_object):
QMainWindow.__init__(self)
self.config = config
self.network = network
-
- self._close_electrum = False
+ self.tray = gui_object.tray
+ self.go_lite = gui_object.go_lite
self.lite = None
- if sys.platform == 'darwin':
- self.icon = QIcon(":icons/electrum_dark_icon.png")
- #self.icon = QIcon(":icons/lock.png")
- else:
- self.icon = QIcon(':icons/electrum_light_icon.png')
-
- self.tray = QSystemTrayIcon(self.icon, self)
- self.tray.setToolTip('Electrum')
- self.tray.activated.connect(self.tray_activated)
-
- self.build_menu()
- self.tray.show()
self.create_status_bar()
-
self.need_update = threading.Event()
- self.decimal_point = config.get('decimal_point', 8)
+ self.decimal_point = config.get('decimal_point', 5)
self.num_zeros = int(config.get('num_zeros',0))
set_language(config.get('language'))
self.funds_error = False
+ self.payment_request = None
self.completions = QStringListModel()
self.tabs = tabs = QTabWidget(self)
g = self.config.get("winpos-qt",[100, 100, 840, 400])
self.setGeometry(g[0], g[1], g[2], g[3])
+ if self.config.get("is_maximized"):
+ self.showMaximized()
self.setWindowIcon(QIcon(":icons/electrum.png"))
self.init_menubar()
QShortcut(QKeySequence("Ctrl+W"), self, self.close)
- QShortcut(QKeySequence("Ctrl+R"), self, self.update_wallet)
QShortcut(QKeySequence("Ctrl+Q"), self, self.close)
+ QShortcut(QKeySequence("Ctrl+R"), self, self.update_wallet)
QShortcut(QKeySequence("Ctrl+PgUp"), self, lambda: tabs.setCurrentIndex( (tabs.currentIndex() - 1 )%tabs.count() ))
QShortcut(QKeySequence("Ctrl+PgDown"), self, lambda: tabs.setCurrentIndex( (tabs.currentIndex() + 1 )%tabs.count() ))
-
+
+ for i in range(tabs.count()):
+ QShortcut(QKeySequence("Alt+" + str(i + 1)), self, lambda i=i: tabs.setCurrentIndex(i))
+
self.connect(self, QtCore.SIGNAL('update_status'), self.update_status)
self.connect(self, QtCore.SIGNAL('banner_signal'), lambda: self.console.showMessage(self.network.banner) )
self.connect(self, QtCore.SIGNAL('transaction_signal'), lambda: self.notify_transactions() )
+ self.connect(self, QtCore.SIGNAL('send_tx2'), self.send_tx2)
+ self.connect(self, QtCore.SIGNAL('send_tx3'), self.send_tx3)
+ self.connect(self, QtCore.SIGNAL('payment_request_ok'), self.payment_request_ok)
self.history_list.setFocus(True)
self.console.showMessage(self.network.banner)
self.wallet = None
- self.init_lite()
-
-
- def go_full(self):
- self.config.set_key('lite_mode', False, True)
- self.mini.hide()
- self.show()
-
- def go_lite(self):
- self.config.set_key('lite_mode', True, True)
- self.hide()
- self.mini.show()
-
-
- def init_lite(self):
- import lite_window
- if not self.check_qt_version():
- if self.config.get('lite_mode') is True:
- msg = "Electrum was unable to load the 'Lite GUI' because it needs Qt version >= 4.7.\nChanging your config to use the 'Classic' GUI"
- QMessageBox.warning(None, "Could not start Lite GUI.", msg)
- self.config.set_key('lite_mode', False, True)
- sys.exit(0)
- self.mini = None
- self.show()
- return
-
- actuator = lite_window.MiniActuator(self)
-
- # Should probably not modify the current path but instead
- # change the behaviour of rsrc(...)
- old_path = QDir.currentPath()
- actuator.load_theme()
-
- self.mini = lite_window.MiniWindow(actuator, self.go_full, self.config)
-
- driver = lite_window.MiniDriver(self, self.mini)
-
- # Reset path back to original value now that loading the GUI
- # is completed.
- QDir.setCurrent(old_path)
-
- if self.config.get('lite_mode') is True:
- self.go_lite()
- else:
- self.go_full()
- def check_qt_version(self):
- qtVersion = qVersion()
- return int(qtVersion[0]) >= 4 and int(qtVersion[2]) >= 7
-
-
def update_account_selector(self):
# account selector
accounts = self.wallet.get_account_names()
# Once GUI has been initialized check if we want to announce something since the callback has been called before the GUI was initialized
self.notify_transactions()
self.update_account_selector()
- self.new_account.setEnabled(self.wallet.seed_version>4)
+ # update menus
+ self.new_account_menu.setEnabled(self.wallet.can_create_accounts())
+ self.private_keys_menu.setEnabled(not self.wallet.is_watching_only())
+ self.password_menu.setEnabled(not self.wallet.is_watching_only())
+ self.seed_menu.setEnabled(self.wallet.has_seed())
+ self.mpk_menu.setEnabled(self.wallet.is_deterministic())
+ self.import_menu.setEnabled(self.wallet.can_import())
+
self.update_lock_icon()
self.update_buttons_on_seed()
self.update_console()
return
self.wallet.stop_threads()
-
- # create new wallet
+
+ # create new wallet
wallet = Wallet(storage)
wallet.start_threads(self.network)
return
wizard = installwizard.InstallWizard(self.config, self.network, storage)
- wallet = wizard.run()
- if wallet:
+ wallet = wizard.run('new')
+ if wallet:
self.load_wallet(wallet)
menubar = QMenuBar()
file_menu = menubar.addMenu(_("&File"))
- open_wallet_action = file_menu.addAction(_("&Open"))
- open_wallet_action.triggered.connect(self.open_wallet)
-
- new_wallet_action = file_menu.addAction(_("&Create/Restore"))
- new_wallet_action.triggered.connect(self.new_wallet)
-
- wallet_backup = file_menu.addAction(_("&Copy"))
- wallet_backup.triggered.connect(self.backup_wallet)
-
- quit_item = file_menu.addAction(_("&Close"))
- quit_item.triggered.connect(self.close)
+ file_menu.addAction(_("&Open"), self.open_wallet).setShortcut(QKeySequence.Open)
+ file_menu.addAction(_("&New/Restore"), self.new_wallet).setShortcut(QKeySequence.New)
+ file_menu.addAction(_("&Save Copy"), self.backup_wallet).setShortcut(QKeySequence.SaveAs)
+ file_menu.addAction(_("&Quit"), self.close)
wallet_menu = menubar.addMenu(_("&Wallet"))
-
- new_contact = wallet_menu.addAction(_("&New contact"))
- new_contact.triggered.connect(self.new_contact_dialog)
-
- self.new_account = wallet_menu.addAction(_("&New account"))
- self.new_account.triggered.connect(self.new_account_dialog)
+ wallet_menu.addAction(_("&New contact"), self.new_contact_dialog)
+ self.new_account_menu = wallet_menu.addAction(_("&New account"), self.new_account_dialog)
wallet_menu.addSeparator()
- pw = wallet_menu.addAction(_("&Password"))
- pw.triggered.connect(self.change_password_dialog)
-
- show_seed = wallet_menu.addAction(_("&Seed"))
- show_seed.triggered.connect(self.show_seed_dialog)
-
- show_mpk = wallet_menu.addAction(_("&Master Public Key"))
- show_mpk.triggered.connect(self.show_master_public_key)
+ self.password_menu = wallet_menu.addAction(_("&Password"), self.change_password_dialog)
+ self.seed_menu = wallet_menu.addAction(_("&Seed"), self.show_seed_dialog)
+ self.mpk_menu = wallet_menu.addAction(_("&Master Public Keys"), self.show_master_public_keys)
wallet_menu.addSeparator()
-
labels_menu = wallet_menu.addMenu(_("&Labels"))
- import_labels = labels_menu.addAction(_("&Import"))
- import_labels.triggered.connect(self.do_import_labels)
- export_labels = labels_menu.addAction(_("&Export"))
- export_labels.triggered.connect(self.do_export_labels)
-
- keys_menu = wallet_menu.addMenu(_("&Private keys"))
- import_keys = keys_menu.addAction(_("&Import"))
- import_keys.triggered.connect(self.do_import_privkey)
- export_keys = keys_menu.addAction(_("&Export"))
- export_keys.triggered.connect(self.do_export_privkeys)
-
- ex_history = wallet_menu.addAction(_("&Export History"))
- ex_history.triggered.connect(self.do_export_history)
-
+ labels_menu.addAction(_("&Import"), self.do_import_labels)
+ labels_menu.addAction(_("&Export"), self.do_export_labels)
+ self.private_keys_menu = wallet_menu.addMenu(_("&Private keys"))
+ self.private_keys_menu.addAction(_("&Sweep"), self.sweep_key_dialog)
+ self.import_menu = self.private_keys_menu.addAction(_("&Import"), self.do_import_privkey)
+ self.private_keys_menu.addAction(_("&Export"), self.export_privkeys_dialog)
+ wallet_menu.addAction(_("&Export History"), self.export_history_dialog)
tools_menu = menubar.addMenu(_("&Tools"))
# Settings / Preferences are all reserved keywords in OSX using this as work around
- preferences_name = _("Electrum preferences") if sys.platform == 'darwin' else _("Preferences")
- preferences_menu = tools_menu.addAction(preferences_name)
- preferences_menu.triggered.connect(self.settings_dialog)
-
- network = tools_menu.addAction(_("&Network"))
- network.triggered.connect(self.run_network_dialog)
-
- plugins_labels = tools_menu.addAction(_("&Plugins"))
- plugins_labels.triggered.connect(self.plugins_dialog)
-
+ tools_menu.addAction(_("Electrum preferences") if sys.platform == 'darwin' else _("Preferences"), self.settings_dialog)
+ tools_menu.addAction(_("&Network"), self.run_network_dialog)
+ 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.addSeparator()
csv_transaction_menu = tools_menu.addMenu(_("&Create transaction"))
-
- csv_transaction_file = csv_transaction_menu.addAction(_("&From CSV file"))
- csv_transaction_file.triggered.connect(self.do_process_from_csv_file)
-
- csv_transaction_text = csv_transaction_menu.addAction(_("&From CSV text"))
- csv_transaction_text.triggered.connect(self.do_process_from_csv_text)
+ csv_transaction_menu.addAction(_("&From CSV file"), self.do_process_from_csv_file)
+ csv_transaction_menu.addAction(_("&From CSV text"), self.do_process_from_csv_text)
raw_transaction_menu = tools_menu.addMenu(_("&Load transaction"))
-
- raw_transaction_file = raw_transaction_menu.addAction(_("&From file"))
- raw_transaction_file.triggered.connect(self.do_process_from_file)
-
- raw_transaction_text = raw_transaction_menu.addAction(_("&From text"))
- raw_transaction_text.triggered.connect(self.do_process_from_text)
-
+ 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)
help_menu = menubar.addMenu(_("&Help"))
- show_about = help_menu.addAction(_("&About"))
- show_about.triggered.connect(self.show_about)
- web_open = help_menu.addAction(_("&Official website"))
- web_open.triggered.connect(lambda: webbrowser.open("http://electrum.org"))
-
+ help_menu.addAction(_("&About"), self.show_about)
+ help_menu.addAction(_("&Official website"), lambda: webbrowser.open("http://electrum.org"))
help_menu.addSeparator()
- doc_open = help_menu.addAction(_("&Documentation"))
- doc_open.triggered.connect(lambda: webbrowser.open("http://electrum.org/documentation.html"))
- report_bug = help_menu.addAction(_("&Report Bug"))
- report_bug.triggered.connect(self.show_report_bug)
+ help_menu.addAction(_("&Documentation"), lambda: webbrowser.open("http://electrum.org/documentation.html")).setShortcut(QKeySequence.HelpContents)
+ help_menu.addAction(_("&Report Bug"), self.show_report_bug)
self.setMenuBar(menubar)
def notify_transactions(self):
- if not self.network or not self.network.is_connected():
+ if not self.network or not self.network.is_connected():
return
print_error("Notifying GUI")
- if len(self.network.interface.pending_transactions_for_notifications) > 0:
+ if len(self.network.pending_transactions_for_notifications) > 0:
# Combine the transactions if there are more then three
- tx_amount = len(self.network.interface.pending_transactions_for_notifications)
+ tx_amount = len(self.network.pending_transactions_for_notifications)
if(tx_amount >= 3):
total_amount = 0
- for tx in self.network.interface.pending_transactions_for_notifications:
+ for tx in self.network.pending_transactions_for_notifications:
is_relevant, is_mine, v, fee = self.wallet.get_tx_value(tx)
if(v > 0):
total_amount += v
self.notify(_("%(txs)s new transactions received. Total amount received in the new transactions %(amount)s %(unit)s") \
% { 'txs' : tx_amount, 'amount' : self.format_amount(total_amount), 'unit' : self.base_unit()})
- self.network.interface.pending_transactions_for_notifications = []
+ self.network.pending_transactions_for_notifications = []
else:
- for tx in self.network.interface.pending_transactions_for_notifications:
+ for tx in self.network.pending_transactions_for_notifications:
if tx:
- self.network.interface.pending_transactions_for_notifications.remove(tx)
+ self.network.pending_transactions_for_notifications.remove(tx)
is_relevant, is_mine, v, fee = self.wallet.get_tx_value(tx)
if(v > 0):
self.notify(_("New transaction received. %(amount)s %(unit)s") % { 'amount' : self.format_amount(v), 'unit' : self.base_unit()})
# custom wrappers for getOpenFileName and getSaveFileName, that remember the path selected by the user
def getOpenFileName(self, title, filter = ""):
- directory = self.config.get('io_dir', os.path.expanduser('~'))
+ directory = self.config.get('io_dir', unicode(os.path.expanduser('~')))
fileName = unicode( QFileDialog.getOpenFileName(self, title, directory, filter) )
if fileName and directory != os.path.dirname(fileName):
self.config.set_key('io_dir', os.path.dirname(fileName), True)
return fileName
def getSaveFileName(self, title, filename, filter = ""):
- directory = self.config.get('io_dir', os.path.expanduser('~'))
+ directory = self.config.get('io_dir', unicode(os.path.expanduser('~')))
path = os.path.join( directory, filename )
fileName = unicode( QFileDialog.getSaveFileName(self, title, path, filter) )
if fileName and directory != os.path.dirname(fileName):
self.update_wallet()
self.need_update.clear()
run_hook('timer_actions')
-
+
def format_amount(self, x, is_diff=False, whitespaces=False):
return format_satoshis(x, is_diff, self.num_zeros, self.decimal_point, whitespaces)
def update_status(self):
- if self.network is None:
+ if self.network is None or not self.network.is_running():
text = _("Offline")
icon = QIcon(":icons/status_disconnected.png")
text = _( "Balance" ) + ": %s "%( self.format_amount(c) ) + self.base_unit()
if u: text += " [%s unconfirmed]"%( self.format_amount(u,True).strip() )
+ # append fiat balance and price from exchange rate plugin
r = {}
- run_hook('set_quote_text', c+u, r)
+ run_hook('get_fiat_status_text', c+u, r)
quote = r.get(0)
if quote:
- text += " (%s)"%quote
+ text += "%s"%quote
self.tray.setToolTip(text)
icon = QIcon(":icons/status_connected.png")
self.update_contacts_tab()
self.update_completions()
-
+
def create_history_tab(self):
self.history_list = l = MyTreeWidget(self)
l.setColumnCount(5)
def create_history_menu(self, position):
- self.history_list.selectedIndexes()
+ self.history_list.selectedIndexes()
item = self.history_list.currentItem()
+ be = self.config.get('block_explorer', 'Blockchain.info')
+ if be == 'Blockchain.info':
+ block_explorer = 'https://blockchain.info/tx/'
+ elif be == 'Blockr.io':
+ block_explorer = 'https://blockr.io/tx/info/'
+ elif be == 'Insight.is':
+ block_explorer = 'http://live.insight.is/tx/'
if not item: return
tx_hash = str(item.data(0, Qt.UserRole).toString())
if not tx_hash: return
menu.addAction(_("Copy ID to Clipboard"), lambda: self.app.clipboard().setText(tx_hash))
menu.addAction(_("Details"), lambda: self.show_transaction(self.wallet.transactions.get(tx_hash)))
menu.addAction(_("Edit description"), lambda: self.tx_label_clicked(item,2))
+ menu.addAction(_("View on block explorer"), lambda: webbrowser.open(block_explorer + tx_hash))
menu.exec_(self.contacts_list.viewport().mapToGlobal(position))
self.is_edit=False
def tx_label_changed(self, item, column):
- if self.is_edit:
+ if self.is_edit:
return
self.is_edit=True
tx_hash = str(item.data(0, Qt.UserRole).toString())
tx = self.wallet.transactions.get(tx_hash)
text = unicode( item.text(2) )
- self.wallet.set_label(tx_hash, text)
- if text:
+ self.wallet.set_label(tx_hash, text)
+ if text:
item.setForeground(2, QBrush(QColor('black')))
else:
text = self.wallet.get_default_label(tx_hash)
if changed:
self.update_history_tab()
self.update_completions()
-
+
self.current_item_changed(item)
run_hook('item_changed', item, column)
v_str = '--'
balance_str = self.format_amount(balance, whitespaces=True)
-
+
if tx_hash:
label, is_default_label = self.wallet.get_label(tx_hash)
else:
item.setIcon(0, icon)
self.history_list.insertTopLevelItem(0,item)
-
+
self.history_list.setCurrentItem(self.history_list.topLevelItem(0))
+ run_hook('history_tab_update')
def create_send_tab(self):
self.payto_e = QLineEdit()
grid.addWidget(QLabel(_('Pay to')), 1, 0)
grid.addWidget(self.payto_e, 1, 1, 1, 3)
-
+
grid.addWidget(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)')), 1, 4)
completer = QCompleter()
grid.addWidget(self.message_e, 2, 1, 1, 3)
grid.addWidget(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.')), 2, 4)
+ self.from_label = QLabel(_('From'))
+ grid.addWidget(self.from_label, 3, 0)
+ self.from_list = QTreeWidget(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.setMaximumHeight(80)
+ grid.addWidget(self.from_list, 3, 1, 1, 3)
+ self.set_pay_from([])
+
self.amount_e = AmountEdit(self.base_unit)
- grid.addWidget(QLabel(_('Amount')), 3, 0)
- grid.addWidget(self.amount_e, 3, 1, 1, 2)
+ grid.addWidget(QLabel(_('Amount')), 4, 0)
+ grid.addWidget(self.amount_e, 4, 1, 1, 2)
grid.addWidget(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.')), 3, 3)
-
+ + '\n\n' + _('Keyboard shortcut: type "!" to send all your coins.')), 4, 3)
+
self.fee_e = AmountEdit(self.base_unit)
- grid.addWidget(QLabel(_('Fee')), 4, 0)
- grid.addWidget(self.fee_e, 4, 1, 1, 2)
+ grid.addWidget(QLabel(_('Fee')), 5, 0)
+ grid.addWidget(self.fee_e, 5, 1, 1, 2)
grid.addWidget(HelpButton(
_('Bitcoin transactions are in general not free. A transaction fee is paid by the sender of the funds.') + '\n\n'\
+ _('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.')), 4, 3)
+ + _('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)
QShortcut(QKeySequence("Up"), w, w.focusPreviousChild)
QShortcut(QKeySequence("Down"), w, w.focusNextChild)
- w.setLayout(grid)
+ w.setLayout(grid)
w2 = QWidget()
vbox = QVBoxLayout()
if self.amount_e.is_shortcut:
self.amount_e.is_shortcut = False
- c, u = self.wallet.get_account_balance(self.current_account)
- inputs, total, fee = self.wallet.choose_tx_inputs_from_account( c + u, 0, self.current_account)
- fee = self.wallet.estimated_fee(inputs)
+ 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())
+ 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 ) )
return
-
+
amount = self.read_amount(str(self.amount_e.text()))
fee = self.read_amount(str(self.fee_e.text()))
if not is_fee: fee = None
if amount is None:
return
- inputs, total, fee = self.wallet.choose_tx_inputs_from_account( amount, fee, self.current_account )
+ # 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())
if not is_fee:
self.fee_e.setText( self.format_amount( fee ) )
if inputs:
self.funds_error = True
text = _( "Not enough funds" )
c, u = self.wallet.get_frozen_balance()
- if c+u: text += ' (' + self.format_amount(c+u).strip() + self.base_unit() + ' ' +_("are frozen") + ')'
+ if c+u: text += ' (' + self.format_amount(c+u).strip() + ' ' + self.base_unit() + ' ' +_("are frozen") + ')'
self.statusBar().showMessage(text)
self.amount_e.setPalette(palette)
return w2
+ def set_pay_from(self, l):
+ self.pay_from = l
+ 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 update_completions(self):
l = []
for addr,label in self.wallet.labels.items():
def do_send(self):
-
label = unicode( self.message_e.text() )
- 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 self.payment_request:
+ outputs = self.payment_request.outputs
+ amount = self.payment_request.get_amount()
- if not is_valid(to_address):
- QMessageBox.warning(self, _('Error'), _('Invalid Bitcoin Address') + ':\n' + to_address, _('OK'))
- return
+ 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'))
+ return
+
+ try:
+ amount = self.read_amount(unicode( self.amount_e.text()))
+ except Exception:
+ QMessageBox.warning(self, _('Error'), _('Invalid Amount'), _('OK'))
+ return
+
+ outputs = [(to_address, amount)]
- try:
- amount = self.read_amount(unicode( self.amount_e.text()))
- except Exception:
- QMessageBox.warning(self, _('Error'), _('Invalid Amount'), _('OK'))
- return
try:
fee = self.read_amount(unicode( self.fee_e.text()))
except Exception:
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}):
return
+
+ confirm_fee = self.config.get('confirm_fee', 100000)
+ if fee >= confirm_fee:
+ 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(to_address, amount, fee, label)
+ self.send_tx(outputs, fee, label)
+
+
+ def waiting_dialog(self, message):
+ d = QDialog(self)
+ d.setWindowTitle('Please wait')
+ l = QLabel(message)
+ vbox = QVBoxLayout(d)
+ vbox.addWidget(l)
+ d.show()
+ return d
@protected
- def send_tx(self, to_address, amount, fee, label, password):
+ def send_tx(self, outputs, fee, label, password):
+ # first, create an unsigned tx
+ domain = self.get_payment_sources()
try:
- tx = self.wallet.mktx_from_account( [(to_address, amount)], password, fee, self.current_account)
+ tx = self.wallet.make_unsigned_transaction(outputs, fee, None, domain)
+ tx.error = None
except Exception as e:
traceback.print_exc(file=sys.stdout)
self.show_message(str(e))
return
+ # call hook to see if plugin needs gui interaction
+ run_hook('send_tx', tx)
+
+ # sign the tx
+ def sign_thread():
+ time.sleep(0.1)
+ keypairs = {}
+ self.wallet.add_keypairs_from_wallet(tx, keypairs, password)
+ self.wallet.sign_transaction(tx, keypairs, password)
+ self.signed_tx_data = (tx, fee, label)
+ self.emit(SIGNAL('send_tx2'))
+ self.tx_wait_dialog = self.waiting_dialog('Signing..')
+ threading.Thread(target=sign_thread).start()
+
+
+
+ def send_tx2(self):
+ tx, fee, label = self.signed_tx_data
+ self.tx_wait_dialog.accept()
+
+ if tx.error:
+ self.show_message(tx.error)
+ return
+
if tx.requires_fee(self.wallet.verifier) and fee < MIN_RELAY_TX_FEE:
QMessageBox.warning(self, _('Error'), _("This transaction requires a higher fee, or it will not be propagated by the network."), _('OK'))
return
- if label:
+ if label:
self.wallet.set_label(tx.hash(), label)
- if tx.is_complete:
- h = self.wallet.send_tx(tx)
- waiting_dialog(lambda: False if self.wallet.tx_event.isSet() else _("Please wait..."))
- status, msg = self.wallet.receive_tx( h )
- if status:
- QMessageBox.information(self, '', _('Payment sent.')+'\n'+msg, _('OK'))
- self.do_clear()
- self.update_contacts_tab()
- else:
- QMessageBox.warning(self, _('Error'), msg, _('OK'))
- else:
-
+ if not tx.is_complete() or self.config.get('show_before_broadcast'):
self.show_transaction(tx)
+ return
- # add recipient to addressbook
- if to_address not in self.wallet.addressbook and not self.wallet.is_mine(to_address):
- self.wallet.addressbook.append(to_address)
+ def broadcast_thread():
+ if self.payment_request:
+ refund_address = self.wallet.addresses()[0]
+ self.payment_request.send_ack(str(tx), refund_address)
+ self.payment_request = None
+ # note: BIP 70 recommends not broadcasting the tx to the network and letting the merchant do that
+ self.tx_broadcast_result = self.wallet.sendtx(tx)
+ self.emit(SIGNAL('send_tx3'))
+ self.tx_broadcast_dialog = self.waiting_dialog('Broadcasting..')
+ threading.Thread(target=broadcast_thread).start()
- def set_url(self, url):
- address, amount, label, message, signature, identity, url = util.parse_url(url)
+ def send_tx3(self):
+ self.tx_broadcast_dialog.accept()
+ status, msg = self.tx_broadcast_result
+ if status:
+ QMessageBox.information(self, '', _('Payment sent.') + '\n' + msg, _('OK'))
+ self.do_clear()
+ else:
+ QMessageBox.warning(self, _('Error'), msg, _('OK'))
+
+
+
+ def payment_request_ok(self):
+ self.payto_e.setText(self.payment_request.domain)
+ self.payto_e.setReadOnly(True)
+ self.amount_e.setText(self.format_amount(self.payment_request.get_amount()))
+ self.amount_e.setReadOnly(True)
- try:
- if amount and self.base_unit() == 'mBTC': amount = str( 1000* Decimal(amount))
- elif amount: amount = str(Decimal(amount))
- except Exception:
- amount = "0.0"
- QMessageBox.warning(self, _('Error'), _('Invalid Amount'), _('OK'))
- if self.mini:
- self.mini.set_payment_fields(address, amount)
+ def set_send(self, address, amount, label, message):
if label and self.wallet.labels.get(address) != label:
if self.question('Give label "%s" to address %s ?'%(label,address)):
self.wallet.addressbook.append(address)
self.wallet.set_label(address, label)
- run_hook('set_url', url, self.show_message, self.question)
-
self.tabs.setCurrentIndex(1)
label = self.wallet.labels.get(address)
m_addr = label + ' <'+ address +'>' if label else address
if amount:
self.amount_e.setText(amount)
- if identity:
- self.set_frozen(self.payto_e,True)
- self.set_frozen(self.amount_e,True)
- self.set_frozen(self.message_e,True)
- self.payto_sig.setText( ' '+_('The bitcoin URI was signed by')+' ' + identity )
- else:
- self.payto_sig.setVisible(False)
def do_clear(self):
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)
+
+ self.set_pay_from([])
self.update_status()
def set_frozen(self,entry,frozen):
entry.setPalette(palette)
- def toggle_freeze(self,addr):
- if not addr: return
- if addr in self.wallet.frozen_addresses:
- self.wallet.unfreeze(addr)
- else:
- self.wallet.freeze(addr)
+ def set_addrs_frozen(self,addrs,freeze):
+ for addr in addrs:
+ if not addr: continue
+ if addr in self.wallet.frozen_addresses and not freeze:
+ self.wallet.unfreeze(addr)
+ elif addr not in self.wallet.frozen_addresses and freeze:
+ self.wallet.freeze(addr)
self.update_receive_tab()
- def toggle_priority(self,addr):
- if not addr: return
- if addr in self.wallet.prioritized_addresses:
- self.wallet.unprioritize(addr)
- else:
- self.wallet.prioritize(addr)
- self.update_receive_tab()
def create_list_tab(self, headers):
l,w,hbox = self.create_list_tab([ _('Address'), _('Label'), _('Balance'), _('Tx')])
l.setContextMenuPolicy(Qt.CustomContextMenu)
l.customContextMenuRequested.connect(self.create_receive_menu)
+ l.setSelectionMode(QAbstractItemView.ExtendedSelection)
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.connect(l, SIGNAL('currentItemChanged(QTreeWidgetItem*, QTreeWidgetItem*)'), lambda a,b: self.current_item_changed(a))
self.column_widths["receive"] = []
for i in range(self.receive_list.columnCount() -1):
self.column_widths["receive"].append(self.receive_list.columnWidth(i))
-
+
self.column_widths["history"] = []
for i in range(self.history_list.columnCount() - 1):
self.column_widths["history"].append(self.history_list.columnWidth(i))
else:
menu.addAction(_("Maximize"), lambda: self.account_set_expanded(item, k, True))
menu.addAction(_("Rename"), lambda: self.edit_account_label(k))
- menu.addAction(_("View details"), lambda: self.show_account_details(k))
+ if self.wallet.seed_version > 4:
+ menu.addAction(_("View details"), lambda: self.show_account_details(k))
if self.wallet.account_is_pending(k):
menu.addAction(_("Delete"), lambda: self.delete_pending_account(k))
menu.exec_(self.receive_list.viewport().mapToGlobal(position))
def create_receive_menu(self, position):
# fixme: this function apparently has a side effect.
# if it is not called the menu pops up several times
- #self.receive_list.selectedIndexes()
-
- item = self.receive_list.itemAt(position)
- if not item: return
-
- addr = unicode(item.text(0))
- if not is_valid(addr):
- k = str(item.data(0,32).toString())
- if k:
- self.create_account_menu(position, k, item)
- else:
- item.setExpanded(not item.isExpanded())
- return
+ #self.receive_list.selectedIndexes()
+
+ selected = self.receive_list.selectedItems()
+ multi_select = len(selected) > 1
+ addrs = [unicode(item.text(0)) for item in selected]
+ if not multi_select:
+ item = self.receive_list.itemAt(position)
+ if not item: return
+
+ addr = addrs[0]
+ if not is_valid(addr):
+ k = str(item.data(0,32).toString())
+ if k:
+ self.create_account_menu(position, k, item)
+ else:
+ item.setExpanded(not item.isExpanded())
+ return
menu = QMenu()
- menu.addAction(_("Copy to clipboard"), lambda: self.app.clipboard().setText(addr))
- menu.addAction(_("QR code"), lambda: self.show_qrcode("bitcoin:" + addr, _("Address")) )
- menu.addAction(_("Edit label"), lambda: self.edit_label(True))
- if self.wallet.seed:
- menu.addAction(_("Private key"), lambda: self.show_private_key(addr))
- menu.addAction(_("Sign message"), lambda: self.sign_message(addr))
- if addr in self.wallet.imported_keys:
- menu.addAction(_("Remove from wallet"), lambda: self.delete_imported_key(addr))
-
- t = _("Unfreeze") if addr in self.wallet.frozen_addresses else _("Freeze")
- menu.addAction(t, lambda: self.toggle_freeze(addr))
- t = _("Unprioritize") if addr in self.wallet.prioritized_addresses else _("Prioritize")
- menu.addAction(t, lambda: self.toggle_priority(addr))
-
- run_hook('receive_menu', menu)
+ if not multi_select:
+ menu.addAction(_("Copy to clipboard"), lambda: self.app.clipboard().setText(addr))
+ menu.addAction(_("QR code"), lambda: self.show_qrcode("bitcoin:" + addr, _("Address")) )
+ menu.addAction(_("Edit label"), lambda: self.edit_label(True))
+ menu.addAction(_("Public keys"), lambda: self.show_public_keys(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))
+ if self.wallet.is_imported(addr):
+ menu.addAction(_("Remove from wallet"), lambda: self.delete_imported_key(addr))
+
+ if any(addr not in self.wallet.frozen_addresses for addr in addrs):
+ menu.addAction(_("Freeze"), lambda: self.set_addrs_frozen(addrs, True))
+ if any(addr in self.wallet.frozen_addresses for addr in addrs):
+ menu.addAction(_("Unfreeze"), lambda: self.set_addrs_frozen(addrs, False))
+
+ if any(addr not in self.wallet.frozen_addresses for addr in addrs):
+ menu.addAction(_("Send From"), lambda: self.send_from_addresses(addrs))
+
+ run_hook('receive_menu', menu, addrs)
menu.exec_(self.receive_list.viewport().mapToGlobal(position))
+ def get_sendable_balance(self):
+ return sum(sum(self.wallet.get_addr_balance(a)) for a in self.get_payment_sources())
+
+
+ def get_payment_sources(self):
+ if self.pay_from:
+ return self.pay_from
+ else:
+ return self.wallet.get_account_addresses(self.current_account)
+
+
+ def send_from_addresses(self, addrs):
+ self.set_pay_from( addrs )
+ self.tabs.setCurrentIndex(1)
+
+
def payto(self, addr):
if not addr: return
label = self.wallet.labels.get(addr)
def create_contact_menu(self, position):
item = self.contacts_list.itemAt(position)
- if not item: return
- addr = unicode(item.text(0))
- label = unicode(item.text(1))
- is_editable = item.data(0,32).toBool()
- payto_addr = item.data(0,33).toString()
menu = QMenu()
- menu.addAction(_("Copy to Clipboard"), lambda: self.app.clipboard().setText(addr))
- menu.addAction(_("Pay to"), lambda: self.payto(payto_addr))
- menu.addAction(_("QR code"), lambda: self.show_qrcode("bitcoin:" + addr, _("Address")))
- if is_editable:
- menu.addAction(_("Edit label"), lambda: self.edit_label(False))
- menu.addAction(_("Delete"), lambda: self.delete_contact(addr))
+ if not item:
+ menu.addAction(_("New contact"), lambda: self.new_contact_dialog())
+ else:
+ addr = unicode(item.text(0))
+ label = unicode(item.text(1))
+ is_editable = item.data(0,32).toBool()
+ payto_addr = item.data(0,33).toString()
+ menu.addAction(_("Copy to Clipboard"), lambda: self.app.clipboard().setText(addr))
+ menu.addAction(_("Pay to"), lambda: self.payto(payto_addr))
+ menu.addAction(_("QR code"), lambda: self.show_qrcode("bitcoin:" + addr, _("Address")))
+ if is_editable:
+ menu.addAction(_("Edit label"), lambda: self.edit_label(False))
+ menu.addAction(_("Delete"), lambda: self.delete_contact(addr))
run_hook('create_contact_menu', menu, item)
menu.exec_(self.contacts_list.viewport().mapToGlobal(position))
- def update_receive_item(self, item, num_tx = 0):
+ def update_receive_item(self, item):
item.setFont(0, QFont(MONOSPACE_FONT))
address = str(item.data(0,0).toString())
label = self.wallet.labels.get(address,'')
balance = self.format_amount(c + u)
item.setData(2,0,balance)
- if (num_tx > 1) and (c == -u):
- item.setForeground(0,QColor('lightgray'))
- item.setForeground(1,QColor('gray'))
- item.setForeground(2,QColor('gray'))
- item.setForeground(3,QColor('gray'))
- elif address in self.wallet.frozen_addresses:
+ if address in self.wallet.frozen_addresses:
item.setBackgroundColor(0, QColor('lightblue'))
- elif address in self.wallet.prioritized_addresses:
- item.setBackgroundColor(0, QColor('lightgreen'))
def update_receive_tab(self):
l = self.receive_list
-
+ # extend the syntax for consistency
+ l.addChild = l.addTopLevelItem
+
l.clear()
- l.setColumnHidden(2, False)
- l.setColumnHidden(3, False)
for i,width in enumerate(self.column_widths['receive']):
l.setColumnWidth(i, width)
+ accounts = self.wallet.get_accounts()
if self.current_account is None:
- account_items = self.wallet.accounts.items()
- elif self.current_account != -1:
- account_items = [(self.current_account, self.wallet.accounts.get(self.current_account))]
+ account_items = sorted(accounts.items())
else:
- account_items = []
+ account_items = [(self.current_account, accounts.get(self.current_account))]
+
for k, account in account_items:
- name = self.wallet.get_account_name(k)
- c,u = self.wallet.get_account_balance(k)
- account_item = QTreeWidgetItem( [ name, '', self.format_amount(c+u), ''] )
- l.addTopLevelItem(account_item)
- account_item.setExpanded(self.accounts_expanded.get(k, True))
- account_item.setData(0, 32, k)
-
- if not self.wallet.is_seeded(k):
- icon = QIcon(":icons/key.png")
- account_item.setIcon(0, icon)
-
- for is_change in ([0,1]):
- name = _("Receiving") if not is_change else _("Change")
- seq_item = QTreeWidgetItem( [ name, '', '', '', ''] )
- account_item.addChild(seq_item)
+
+ if len(accounts) > 1:
+ name = self.wallet.get_account_name(k)
+ c,u = self.wallet.get_account_balance(k)
+ account_item = QTreeWidgetItem( [ name, '', self.format_amount(c+u), ''] )
+ l.addTopLevelItem(account_item)
+ account_item.setExpanded(self.accounts_expanded.get(k, True))
+ account_item.setData(0, 32, k)
+ else:
+ account_item = l
+
+ sequences = [0,1] if account.has_change() else [0]
+ for is_change in sequences:
+ if len(sequences) > 1:
+ name = _("Receiving") if not is_change else _("Change")
+ seq_item = QTreeWidgetItem( [ name, '', '', '', ''] )
+ account_item.addChild(seq_item)
+ if not is_change:
+ seq_item.setExpanded(True)
+ else:
+ seq_item = account_item
+
used_item = QTreeWidgetItem( [ _("Used"), '', '', '', ''] )
- seq_item.addChild(used_item)
- if not is_change: seq_item.setExpanded(True)
+ used_flag = False
is_red = False
gap = 0
for address in account.get_addresses(is_change):
h = self.wallet.history.get(address,[])
-
+
if h == []:
gap += 1
if gap > self.wallet.gap_limit:
c, u = self.wallet.get_addr_balance(address)
num_tx = '*' if h == ['*'] else "%d"%len(h)
+
item = QTreeWidgetItem( [ address, '', '', num_tx] )
- self.update_receive_item(item, len(h))
+ self.update_receive_item(item)
if is_red:
item.setBackgroundColor(1, QColor('red'))
if len(h) > 0 and c == -u:
+ if not used_flag:
+ seq_item.insertChild(0,used_item)
+ used_flag = True
used_item.addChild(item)
else:
seq_item.addChild(item)
-
- for k, addr in self.wallet.get_pending_accounts():
- name = self.wallet.labels.get(k,'')
- account_item = QTreeWidgetItem( [ name + " [ "+_('pending account')+" ]", '', '', ''] )
- self.update_receive_item(item)
- l.addTopLevelItem(account_item)
- account_item.setExpanded(True)
- account_item.setData(0, 32, k)
- item = QTreeWidgetItem( [ addr, '', '', '', ''] )
- account_item.addChild(item)
- self.update_receive_item(item)
-
-
- if self.wallet.imported_keys and (self.current_account is None or self.current_account == -1):
- c,u = self.wallet.get_imported_balance()
- account_item = QTreeWidgetItem( [ _('Imported'), '', self.format_amount(c+u), ''] )
- l.addTopLevelItem(account_item)
- account_item.setExpanded(True)
- for address in self.wallet.imported_keys.keys():
- item = QTreeWidgetItem( [ address, '', '', ''] )
- self.update_receive_item(item)
- account_item.addChild(item)
-
-
# we use column 1 because column 0 may be hidden
l.setCurrentItem(l.topLevelItem(0),1)
for m in dir(c):
if m[0]=='_' or m in ['network','wallet']: continue
methods[m] = mkfunc(c._run, m)
-
+
console.updateNamespace(methods)
self.updatelabel = UpdateLabel(self.config, sb)
self.account_selector = QComboBox()
- self.connect(self.account_selector,SIGNAL("activated(QString)"),self.change_account)
+ self.account_selector.setSizeAdjustPolicy(QComboBox.AdjustToContents)
+ self.connect(self.account_selector,SIGNAL("activated(QString)"),self.change_account)
sb.addPermanentWidget(self.account_selector)
if (int(qtVersion[0]) >= 4 and int(qtVersion[2]) >= 7):
self.lock_icon = QIcon()
self.password_button = StatusBarButton( self.lock_icon, _("Password"), self.change_password_dialog )
sb.addPermanentWidget( self.password_button )
-
+
sb.addPermanentWidget( StatusBarButton( QIcon(":icons/preferences.png"), _("Preferences"), self.settings_dialog ) )
- self.seed_button = StatusBarButton( QIcon(":icons/seed.png"), _("Seed"), self.show_seed_dialog )
+ self.seed_button = StatusBarButton( QIcon(":icons/seed.png"), _("Seed"), self.show_seed_dialog )
sb.addPermanentWidget( self.seed_button )
- self.status_button = StatusBarButton( QIcon(":icons/status_disconnected.png"), _("Network"), self.run_network_dialog )
+ self.status_button = StatusBarButton( QIcon(":icons/status_disconnected.png"), _("Network"), self.run_network_dialog )
sb.addPermanentWidget( self.status_button )
run_hook('create_status_bar', (sb,))
def update_buttons_on_seed(self):
- if not self.wallet.is_watching_only():
+ if self.wallet.has_seed():
self.seed_button.show()
+ else:
+ self.seed_button.hide()
+
+ if not self.wallet.is_watching_only():
self.password_button.show()
self.send_button.setText(_("Send"))
else:
self.password_button.hide()
- self.seed_button.hide()
self.send_button.setText(_("Create unsigned transaction"))
def new_contact_dialog(self):
d = QDialog(self)
+ d.setWindowTitle(_("New Contact"))
vbox = QVBoxLayout(d)
vbox.addWidget(QLabel(_('New Contact')+':'))
-
+
grid = QGridLayout()
line1 = QLineEdit()
line2 = QLineEdit()
vbox.addLayout(grid)
vbox.addLayout(ok_cancel_buttons(d))
-
+
if not d.exec_():
return
-
+
address = str(line1.text())
label = unicode(line2.text())
-
+
if not is_valid(address):
QMessageBox.warning(self, _('Error'), _('Invalid Address'), _('OK'))
return
-
+
self.wallet.add_contact(address)
if label:
self.wallet.set_label(address, label)
self.tabs.setCurrentIndex(3)
- def new_account_dialog(self):
+ @protected
+ def new_account_dialog(self, password):
dialog = QDialog(self)
dialog.setModal(1)
name = str(e.text())
if not name: return
- self.wallet.create_pending_account('1', name)
+ self.wallet.create_pending_account(name, password)
self.update_receive_tab()
self.tabs.setCurrentIndex(2)
-
-
-
- def show_master_public_key_old(self):
- dialog = QDialog(self)
- dialog.setModal(1)
- dialog.setWindowTitle(_("Master Public Key"))
- main_text = QTextEdit()
- main_text.setText(self.wallet.get_master_public_key())
- main_text.setReadOnly(True)
- main_text.setMaximumHeight(170)
- qrw = QRCodeWidget(self.wallet.get_master_public_key())
- ok_button = QPushButton(_("OK"))
- ok_button.setDefault(True)
- ok_button.clicked.connect(dialog.accept)
- main_layout = QGridLayout()
- main_layout.addWidget(QLabel(_('Your Master Public Key is:')), 0, 0, 1, 2)
- main_layout.addWidget(main_text, 1, 0)
- main_layout.addWidget(qrw, 1, 1 )
-
- vbox = QVBoxLayout()
- vbox.addLayout(main_layout)
- vbox.addLayout(close_button(dialog))
- dialog.setLayout(vbox)
- dialog.exec_()
-
-
- def show_master_public_key(self):
-
- if self.wallet.seed_version == 4:
- self.show_master_public_key_old()
- return
+ def show_master_public_keys(self):
dialog = QDialog(self)
dialog.setModal(1)
dialog.setWindowTitle(_("Master Public Keys"))
- chain_text = QTextEdit()
- chain_text.setReadOnly(True)
- chain_text.setMaximumHeight(170)
- chain_qrw = QRCodeWidget()
-
- mpk_text = QTextEdit()
- mpk_text.setReadOnly(True)
- mpk_text.setMaximumHeight(170)
- mpk_qrw = QRCodeWidget()
-
main_layout = QGridLayout()
-
- main_layout.addWidget(QLabel(_('Key')), 1, 0)
- main_layout.addWidget(mpk_text, 1, 1)
- main_layout.addWidget(mpk_qrw, 1, 2)
-
- main_layout.addWidget(QLabel(_('Chain')), 2, 0)
- main_layout.addWidget(chain_text, 2, 1)
- main_layout.addWidget(chain_qrw, 2, 2)
-
- def update(key):
- c, K, cK = self.wallet.master_public_keys[str(key)]
- chain_text.setText(c)
- chain_qrw.set_addr(c)
- chain_qrw.update_qr()
- mpk_text.setText(K)
- mpk_qrw.set_addr(K)
- mpk_qrw.update_qr()
-
- key_selector = QComboBox()
- keys = sorted(self.wallet.master_public_keys.keys())
- key_selector.addItems(keys)
-
- main_layout.addWidget(QLabel(_('Derivation:')), 0, 0)
- main_layout.addWidget(key_selector, 0, 1)
- dialog.connect(key_selector,SIGNAL("activated(QString)"),update)
-
- update(keys[0])
+ mpk_dict = self.wallet.get_master_public_keys()
+ i = 0
+ for key, value in mpk_dict.items():
+ main_layout.addWidget(QLabel(key), i, 0)
+ mpk_text = QTextEdit()
+ mpk_text.setReadOnly(True)
+ mpk_text.setMaximumHeight(170)
+ mpk_text.setText(value)
+ main_layout.addWidget(mpk_text, i + 1, 0)
+ i += 2
vbox = QVBoxLayout()
vbox.addLayout(main_layout)
dialog.setLayout(vbox)
dialog.exec_()
-
+
@protected
def show_seed_dialog(self, password):
- if self.wallet.is_watching_only():
- QMessageBox.information(self, _('Message'), _('This is a watching-only wallet'), _('OK'))
+ if not self.wallet.has_seed():
+ QMessageBox.information(self, _('Message'), _('This wallet has no seed'), _('OK'))
return
- if self.wallet.seed:
- try:
- mnemonic = self.wallet.get_mnemonic(password)
- except Exception:
- QMessageBox.warning(self, _('Error'), _('Incorrect Password'), _('OK'))
- return
- from seed_dialog import SeedDialog
- d = SeedDialog(self, mnemonic, self.wallet.imported_keys)
- d.exec_()
- else:
- l = {}
- for k in self.wallet.master_private_keys.keys():
- pk = self.wallet.get_master_private_key(k, password)
- l[k] = pk
- from seed_dialog import PrivateKeysDialog
- d = PrivateKeysDialog(self,l)
- d.exec_()
-
-
+ try:
+ mnemonic = self.wallet.get_mnemonic(password)
+ except Exception:
+ QMessageBox.warning(self, _('Error'), _('Incorrect Password'), _('OK'))
+ return
+ from seed_dialog import SeedDialog
+ d = SeedDialog(self, mnemonic, self.wallet.imported_keys)
+ d.exec_()
return
else:
password = None
-
+
if args != (False,):
args = (self,) + args + (password,)
else:
apply( func, args)
+ def show_public_keys(self, address):
+ if not address: return
+ try:
+ pubkey_list = self.wallet.get_public_keys(address)
+ except Exception as e:
+ traceback.print_exc(file=sys.stdout)
+ self.show_message(str(e))
+ return
+
+ d = QDialog(self)
+ d.setMinimumSize(600, 200)
+ d.setModal(1)
+ vbox = QVBoxLayout()
+ vbox.addWidget( QLabel(_("Address") + ': ' + address))
+ vbox.addWidget( QLabel(_("Public key") + ':'))
+ keys = QTextEdit()
+ keys.setReadOnly(True)
+ keys.setText('\n'.join(pubkey_list))
+ vbox.addWidget(keys)
+ #vbox.addWidget( QRCodeWidget('\n'.join(pk_list)) )
+ vbox.addLayout(close_button(d))
+ d.setLayout(vbox)
+ d.exec_()
+
@protected
def show_private_key(self, address, password):
if not address: return
try:
pk_list = self.wallet.get_private_key(address, password)
except Exception as e:
+ traceback.print_exc(file=sys.stdout)
self.show_message(str(e))
return
- QMessageBox.information(self, _('Private key'), _('Address')+ ': ' + address + '\n\n' + _('Private key') + ': ' + '\n'.join(pk_list), _('OK'))
+
+ d = QDialog(self)
+ d.setMinimumSize(600, 200)
+ d.setModal(1)
+ vbox = QVBoxLayout()
+ vbox.addWidget( QLabel(_("Address") + ': ' + address))
+ vbox.addWidget( QLabel(_("Private key") + ':'))
+ keys = QTextEdit()
+ keys.setReadOnly(True)
+ keys.setText('\n'.join(pk_list))
+ vbox.addWidget(keys)
+ vbox.addWidget( QRCodeWidget('\n'.join(pk_list)) )
+ vbox.addLayout(close_button(d))
+ d.setLayout(vbox)
+ d.exec_()
@protected
except Exception as e:
self.show_message(str(e))
- def sign_message(self, address):
- if not address: return
+ def do_verify(self, address, message, signature):
+ message = unicode(message.toPlainText())
+ message = message.encode('utf-8')
+ if bitcoin.verify_message(address.text(), str(signature.toPlainText()), message):
+ self.show_message(_("Signature verified"))
+ else:
+ self.show_message(_("Error: wrong signature"))
+
+
+ def sign_verify_message(self, address=''):
d = QDialog(self)
d.setModal(1)
- d.setWindowTitle(_('Sign Message'))
+ d.setWindowTitle(_('Sign/verify Message'))
d.setMinimumSize(410, 290)
- tab_widget = QTabWidget()
- tab = QWidget()
- layout = QGridLayout(tab)
-
- sign_address = QLineEdit()
+ layout = QGridLayout(d)
- sign_address.setText(address)
- layout.addWidget(QLabel(_('Address')), 1, 0)
- layout.addWidget(sign_address, 1, 1)
-
- sign_message = QTextEdit()
- layout.addWidget(QLabel(_('Message')), 2, 0)
- layout.addWidget(sign_message, 2, 1)
+ message_e = QTextEdit()
+ layout.addWidget(QLabel(_('Message')), 1, 0)
+ layout.addWidget(message_e, 1, 1)
layout.setRowStretch(2,3)
- sign_signature = QTextEdit()
+ address_e = QLineEdit()
+ address_e.setText(address)
+ layout.addWidget(QLabel(_('Address')), 2, 0)
+ layout.addWidget(address_e, 2, 1)
+
+ signature_e = QTextEdit()
layout.addWidget(QLabel(_('Signature')), 3, 0)
- layout.addWidget(sign_signature, 3, 1)
+ layout.addWidget(signature_e, 3, 1)
layout.setRowStretch(3,1)
-
hbox = QHBoxLayout()
+
b = QPushButton(_("Sign"))
+ b.clicked.connect(lambda: self.do_sign(address_e, message_e, signature_e))
+ hbox.addWidget(b)
+
+ b = QPushButton(_("Verify"))
+ b.clicked.connect(lambda: self.do_verify(address_e, message_e, signature_e))
hbox.addWidget(b)
- b.clicked.connect(lambda: self.do_sign(sign_address, sign_message, sign_signature))
+
b = QPushButton(_("Close"))
b.clicked.connect(d.accept)
hbox.addWidget(b)
layout.addLayout(hbox, 4, 1)
- tab_widget.addTab(tab, _("Sign"))
+ d.exec_()
- tab = QWidget()
- layout = QGridLayout(tab)
+ @protected
+ def do_decrypt(self, message_e, pubkey_e, encrypted_e, password):
+ try:
+ decrypted = self.wallet.decrypt_message(str(pubkey_e.text()), str(encrypted_e.toPlainText()), password)
+ message_e.setText(decrypted)
+ except Exception as e:
+ self.show_message(str(e))
- verify_address = QLineEdit()
- layout.addWidget(QLabel(_('Address')), 1, 0)
- layout.addWidget(verify_address, 1, 1)
- verify_message = QTextEdit()
- layout.addWidget(QLabel(_('Message')), 2, 0)
- layout.addWidget(verify_message, 2, 1)
+ def do_encrypt(self, message_e, pubkey_e, encrypted_e):
+ message = unicode(message_e.toPlainText())
+ message = message.encode('utf-8')
+ try:
+ encrypted = bitcoin.encrypt_message(message, str(pubkey_e.text()))
+ encrypted_e.setText(encrypted)
+ except Exception as e:
+ self.show_message(str(e))
+
+
+
+ def encrypt_message(self, address = ''):
+ d = QDialog(self)
+ d.setModal(1)
+ d.setWindowTitle(_('Encrypt/decrypt Message'))
+ d.setMinimumSize(610, 490)
+
+ layout = QGridLayout(d)
+
+ message_e = QTextEdit()
+ layout.addWidget(QLabel(_('Message')), 1, 0)
+ layout.addWidget(message_e, 1, 1)
layout.setRowStretch(2,3)
- verify_signature = QTextEdit()
- layout.addWidget(QLabel(_('Signature')), 3, 0)
- layout.addWidget(verify_signature, 3, 1)
- layout.setRowStretch(3,1)
+ pubkey_e = QLineEdit()
+ if address:
+ pubkey = self.wallet.getpubkeys(address)[0]
+ pubkey_e.setText(pubkey)
+ layout.addWidget(QLabel(_('Public key')), 2, 0)
+ layout.addWidget(pubkey_e, 2, 1)
- def do_verify():
- message = unicode(verify_message.toPlainText())
- message = message.encode('utf-8')
- if bitcoin.verify_message(verify_address.text(), str(verify_signature.toPlainText()), message):
- self.show_message(_("Signature verified"))
- else:
- self.show_message(_("Error: wrong signature"))
+ encrypted_e = QTextEdit()
+ layout.addWidget(QLabel(_('Encrypted')), 3, 0)
+ layout.addWidget(encrypted_e, 3, 1)
+ layout.setRowStretch(3,1)
hbox = QHBoxLayout()
- b = QPushButton(_("Verify"))
- b.clicked.connect(do_verify)
+ b = QPushButton(_("Encrypt"))
+ b.clicked.connect(lambda: self.do_encrypt(message_e, pubkey_e, encrypted_e))
+ hbox.addWidget(b)
+
+ b = QPushButton(_("Decrypt"))
+ b.clicked.connect(lambda: self.do_decrypt(message_e, pubkey_e, encrypted_e))
hbox.addWidget(b)
+
b = QPushButton(_("Close"))
b.clicked.connect(d.accept)
hbox.addWidget(b)
- layout.addLayout(hbox, 4, 1)
- tab_widget.addTab(tab, _("Verify"))
- vbox = QVBoxLayout()
- vbox.addWidget(tab_widget)
- d.setLayout(vbox)
+ layout.addLayout(hbox, 4, 1)
d.exec_()
-
-
def question(self, msg):
return QMessageBox.question(self, _('Message'), msg, QMessageBox.Yes | QMessageBox.No, QMessageBox.No) == QMessageBox.Yes
def password_dialog(self ):
d = QDialog(self)
d.setModal(1)
+ d.setWindowTitle(_("Enter Password"))
pw = QLineEdit()
pw.setEchoMode(2)
return tx
except Exception:
pass
-
+
QMessageBox.critical(None, _("Unable to parse transaction"), _("Electrum was unable to parse your transaction"))
if tx:
self.show_transaction(tx)
+ def do_process_from_txid(self):
+ from electrum import transaction
+ txid, ok = QInputDialog.getText(self, _('Lookup transaction'), _('Transaction ID') + ':')
+ if ok and txid:
+ r = self.network.synchronous_get([ ('blockchain.transaction.get',[str(txid)]) ])[0]
+ if r:
+ tx = transaction.Transaction(r)
+ if tx:
+ self.show_transaction(tx)
+ else:
+ self.show_message("unknown transaction")
+
def do_process_from_csvReader(self, csvReader):
outputs = []
+ errors = []
+ errtext = ""
try:
- for row in csvReader:
+ for position, row in enumerate(csvReader):
address = row[0]
- amount = float(row[1])
+ if not is_valid(address):
+ errors.append((position, address))
+ continue
+ amount = Decimal(row[1])
amount = int(100000000*amount)
outputs.append((address, amount))
except (ValueError, IOError, os.error), reason:
QMessageBox.critical(None, _("Unable to read file or no transaction found"), _("Electrum was unable to open your transaction file") + "\n" + str(reason))
return
+ if errors != []:
+ for x in errors:
+ errtext += "CSV Row " + str(x[0]+1) + ": " + x[1] + "\n"
+ QMessageBox.critical(None, _("Invalid Addresses"), _("ABORTING! Invalid Addresses found:") + "\n\n" + errtext)
+ return
try:
tx = self.wallet.make_unsigned_transaction(outputs, None, None)
@protected
- def do_export_privkeys(self, password):
- self.show_message("%s\n%s\n%s" % (_("WARNING: ALL your private keys are secret."), _("Exposing a single private key can compromise your entire wallet!"), _("In particular, DO NOT use 'redeem private key' services proposed by third parties.")))
+ def export_privkeys_dialog(self, password):
+ if self.wallet.is_watching_only():
+ self.show_message(_("This is a watching-only wallet"))
+ return
- try:
- select_export = _('Select file to export your private keys to')
- fileName = self.getSaveFileName(select_export, 'electrum-private-keys.csv', "*.csv")
- if fileName:
- with open(fileName, "w+") as csvfile:
- transaction = csv.writer(csvfile)
- transaction.writerow(["address", "private_key"])
+ d = QDialog(self)
+ d.setWindowTitle(_('Private keys'))
+ d.setMinimumSize(850, 300)
+ vbox = QVBoxLayout(d)
- addresses = self.wallet.addresses(True)
-
- for addr in addresses:
- pk = "".join(self.wallet.get_private_key(addr, password))
- transaction.writerow(["%34s"%addr,pk])
+ msg = "%s\n%s\n%s" % (_("WARNING: ALL your private keys are secret."),
+ _("Exposing a single private key can compromise your entire wallet!"),
+ _("In particular, DO NOT use 'redeem private key' services proposed by third parties."))
+ vbox.addWidget(QLabel(msg))
+
+ e = QTextEdit()
+ e.setReadOnly(True)
+ vbox.addWidget(e)
+
+ defaultname = 'electrum-private-keys.csv'
+ select_msg = _('Select file to export your private keys to')
+ hbox, filename_e, csv_button = filename_field(self, self.config, defaultname, select_msg)
+ vbox.addLayout(hbox)
- self.show_message(_("Private keys exported."))
+ h, b = ok_cancel_buttons2(d, _('Export'))
+ b.setEnabled(False)
+ vbox.addLayout(h)
+
+ private_keys = {}
+ addresses = self.wallet.addresses(True)
+ done = False
+ def privkeys_thread():
+ for addr in addresses:
+ time.sleep(0.1)
+ if done:
+ break
+ private_keys[addr] = "\n".join(self.wallet.get_private_key(addr, password))
+ d.emit(SIGNAL('computing_privkeys'))
+ d.emit(SIGNAL('show_privkeys'))
+
+ def show_privkeys():
+ s = "\n".join( map( lambda x: x[0] + "\t"+ x[1], private_keys.items()))
+ e.setText(s)
+ b.setEnabled(True)
+
+ d.connect(d, QtCore.SIGNAL('computing_privkeys'), lambda: e.setText("Please wait... %d/%d"%(len(private_keys),len(addresses))))
+ d.connect(d, QtCore.SIGNAL('show_privkeys'), show_privkeys)
+ threading.Thread(target=privkeys_thread).start()
+
+ if not d.exec_():
+ done = True
+ return
+
+ filename = filename_e.text()
+ if not filename:
+ return
+ try:
+ self.do_export_privkeys(filename, private_keys, csv_button.isChecked())
except (IOError, os.error), reason:
export_error_label = _("Electrum was unable to produce a private key-export.")
QMessageBox.critical(None, _("Unable to create csv"), export_error_label + "\n" + str(reason))
except Exception as e:
- self.show_message(str(e))
- return
+ self.show_message(str(e))
+ return
+
+ self.show_message(_("Private keys exported."))
+
+
+ def do_export_privkeys(self, fileName, pklist, is_csv):
+ with open(fileName, "w+") as f:
+ if is_csv:
+ transaction = csv.writer(f)
+ transaction.writerow(["address", "private_key"])
+ for addr, pk in pklist.items():
+ transaction.writerow(["%34s"%addr,pk])
+ else:
+ import json
+ f.write(json.dumps(pklist, indent = 4))
def do_import_labels(self):
QMessageBox.information(None, _("Labels imported"), _("Your labels were imported from")+" '%s'" % str(labelsFile))
except (IOError, os.error), reason:
QMessageBox.critical(None, _("Unable to import labels"), _("Electrum was unable to import your labels.")+"\n" + str(reason))
-
+
def do_export_labels(self):
labels = self.wallet.labels
QMessageBox.critical(None, _("Unable to export labels"), _("Electrum was unable to export your labels.")+"\n" + str(reason))
- def do_export_history(self):
- from lite_window import csv_transaction
- csv_transaction(self.wallet)
+ def export_history_dialog(self):
+
+ d = QDialog(self)
+ d.setWindowTitle(_('Export History'))
+ d.setMinimumSize(400, 200)
+ vbox = QVBoxLayout(d)
+
+ defaultname = os.path.expanduser('~/electrum-history.csv')
+ select_msg = _('Select file to export your wallet transactions to')
+
+ hbox, filename_e, csv_button = filename_field(self, self.config, defaultname, select_msg)
+ vbox.addLayout(hbox)
+
+ vbox.addStretch(1)
+
+ h, b = ok_cancel_buttons2(d, _('Export'))
+ vbox.addLayout(h)
+ if not d.exec_():
+ return
+
+ filename = filename_e.text()
+ if not filename:
+ return
+
+ try:
+ self.do_export_history(self.wallet, filename, csv_button.isChecked())
+ except (IOError, os.error), reason:
+ export_error_label = _("Electrum was unable to produce a transaction export.")
+ QMessageBox.critical(self, _("Unable to export history"), export_error_label + "\n" + str(reason))
+ return
+
+ QMessageBox.information(self,_("History exported"), _("Your wallet history has been successfully exported."))
+
+
+ def do_export_history(self, wallet, fileName, is_csv):
+ history = wallet.get_tx_history()
+ lines = []
+ for item in history:
+ tx_hash, confirmations, is_mine, value, fee, balance, timestamp = item
+ if confirmations:
+ if timestamp is not None:
+ try:
+ time_string = datetime.datetime.fromtimestamp(timestamp).isoformat(' ')[:-3]
+ except [RuntimeError, TypeError, NameError] as reason:
+ time_string = "unknown"
+ pass
+ else:
+ time_string = "unknown"
+ else:
+ time_string = "pending"
+
+ if value is not None:
+ value_string = format_satoshis(value, True)
+ else:
+ value_string = '--'
+
+ if fee is not None:
+ fee_string = format_satoshis(fee, True)
+ else:
+ fee_string = '0'
+
+ if tx_hash:
+ label, is_default_label = wallet.get_label(tx_hash)
+ label = label.encode('utf-8')
+ else:
+ label = ""
+
+ balance_string = format_satoshis(balance, False)
+ if is_csv:
+ lines.append([tx_hash, label, confirmations, value_string, fee_string, balance_string, time_string])
+ else:
+ lines.append({'txid':tx_hash, 'date':"%16s"%time_string, 'label':label, 'value':value_string})
+
+ with open(fileName, "w+") as f:
+ if is_csv:
+ transaction = csv.writer(f)
+ transaction.writerow(["transaction_hash","label", "confirmations", "value", "fee", "balance", "timestamp"])
+ for line in lines:
+ transaction.writerow(line)
+ else:
+ import json
+ f.write(json.dumps(lines, indent = 4))
+
+
+ def sweep_key_dialog(self):
+ d = QDialog(self)
+ d.setWindowTitle(_('Sweep private keys'))
+ d.setMinimumSize(600, 300)
+
+ vbox = QVBoxLayout(d)
+ vbox.addWidget(QLabel(_("Enter private keys")))
+
+ keys_e = QTextEdit()
+ keys_e.setTabChangesFocus(True)
+ vbox.addWidget(keys_e)
+
+ h, address_e = address_field(self.wallet.addresses())
+ vbox.addLayout(h)
+
+ vbox.addStretch(1)
+ hbox, button = ok_cancel_buttons2(d, _('Sweep'))
+ vbox.addLayout(hbox)
+ button.setEnabled(False)
+
+ def get_address():
+ addr = str(address_e.text())
+ if bitcoin.is_address(addr):
+ return addr
+
+ def get_pk():
+ pk = str(keys_e.toPlainText()).strip()
+ if Wallet.is_private_key(pk):
+ return pk.split()
+
+ f = lambda: button.setEnabled(get_address() is not None and get_pk() is not None)
+ keys_e.textChanged.connect(f)
+ address_e.textChanged.connect(f)
+ if not d.exec_():
+ return
+
+ fee = self.wallet.fee
+ tx = Transaction.sweep(get_pk(), self.network, get_address(), fee)
+ self.show_transaction(tx)
@protected
except Exception as e:
badkeys.append(key)
continue
- if not addr:
+ if not addr:
badkeys.append(key)
else:
addrlist.append(addr)
grid.addWidget(HelpButton(msg), 0, 2)
if not self.config.is_modifiable('num_zeros'):
for w in [nz_e, nz_label]: w.setEnabled(False)
-
+
lang_label=QLabel(_('Language') + ':')
grid.addWidget(lang_label, 1, 0)
lang_combo = QComboBox()
if not self.config.is_modifiable('language'):
for w in [lang_combo, lang_label]: w.setEnabled(False)
-
+
fee_label = QLabel(_('Transaction fee') + ':')
grid.addWidget(fee_label, 2, 0)
fee_e = AmountEdit(self.base_unit)
grid.addWidget(unit_combo, 3, 1)
grid.addWidget(HelpButton(_('Base unit of your wallet.')\
+ '\n1BTC=1000mBTC.\n' \
- + _(' This settings affects the fields in the Send tab')+' '), 3, 2)
+ + _(' These settings affects the fields in the Send tab')+' '), 3, 2)
usechange_cb = QCheckBox(_('Use change addresses'))
usechange_cb.setChecked(self.wallet.use_change)
grid.addWidget(HelpButton(_('Using change addresses makes it more difficult for other people to track your transactions.')+' '), 4, 2)
if not self.config.is_modifiable('use_change'): usechange_cb.setEnabled(False)
- grid.setRowStretch(5,1)
+ block_explorers = ['Blockchain.info', 'Blockr.io', 'Insight.is']
+ block_ex_label = QLabel(_('Online Block Explorer') + ':')
+ grid.addWidget(block_ex_label, 5, 0)
+ block_ex_combo = QComboBox()
+ block_ex_combo.addItems(block_explorers)
+ block_ex_combo.setCurrentIndex(block_explorers.index(self.config.get('block_explorer', 'Blockchain.info')))
+ grid.addWidget(block_ex_combo, 5, 1)
+ grid.addWidget(HelpButton(_('Choose which online block explorer to use for functions that open a web browser')+' '), 5, 2)
+
+ show_tx = self.config.get('show_before_broadcast', False)
+ showtx_cb = QCheckBox(_('Show before broadcast'))
+ showtx_cb.setChecked(show_tx)
+ grid.addWidget(showtx_cb, 6, 0)
+ grid.addWidget(HelpButton(_('Display the details of your transactions before broadcasting it.')), 6, 2)
vbox.addLayout(grid)
+ vbox.addStretch(1)
vbox.addLayout(ok_cancel_buttons(d))
- d.setLayout(vbox)
+ d.setLayout(vbox)
# run the dialog
if not d.exec_(): return
return
self.wallet.set_fee(fee)
-
+
nz = unicode(nz_e.text())
try:
nz = int( nz )
if self.wallet.use_change != usechange_result:
self.wallet.use_change = usechange_result
self.wallet.storage.put('use_change', self.wallet.use_change)
-
+
+ if showtx_cb.isChecked() != show_tx:
+ self.config.set_key('show_before_broadcast', not show_tx)
+
unit_result = units[unit_combo.currentIndex()]
if self.base_unit() != unit_result:
self.decimal_point = 8 if unit_result == 'BTC' else 5
self.config.set_key('decimal_point', self.decimal_point, True)
self.update_history_tab()
self.update_status()
-
+
need_restart = False
lang_request = languages.keys()[lang_combo.currentIndex()]
if lang_request != self.config.get('language'):
self.config.set_key("language", lang_request, True)
need_restart = True
-
+
+ be_result = block_explorers[block_ex_combo.currentIndex()]
+ self.config.set_key('block_explorer', be_result, True)
+
run_hook('close_settings_dialog')
if need_restart:
NetworkDialog(self.wallet.network, self.config, self).do_exec()
def closeEvent(self, event):
- g = self.geometry()
- self.config.set_key("winpos-qt", [g.left(),g.top(),g.width(),g.height()], True)
+ self.tray.hide()
+ self.config.set_key("is_maximized", self.isMaximized())
+ if not self.isMaximized():
+ g = self.geometry()
+ self.config.set_key("winpos-qt", [g.left(),g.top(),g.width(),g.height()])
self.save_column_widths()
self.config.set_key("console-history", self.console.history[-50:], True)
self.wallet.storage.put('accounts_expanded', self.accounts_expanded)
event.accept()
-
def plugins_dialog(self):
from electrum.plugins import plugins
w = p.settings_widget(self)
w.setEnabled( p.is_enabled() )
grid.addWidget(w, i, 1)
- else:
+ else:
w = None
cb.clicked.connect(mk_toggle(cb,p,w))
grid.addWidget(HelpButton(p.description()), i, 2)
def show_account_details(self, k):
+ account = self.wallet.accounts[k]
+
d = QDialog(self)
d.setWindowTitle(_('Account Details'))
d.setModal(1)
vbox = QVBoxLayout(d)
- roots = self.wallet.get_roots(k)
-
name = self.wallet.get_account_name(k)
label = QLabel('Name: ' + name)
vbox.addWidget(label)
- acctype = '2 of 2' if len(roots) == 2 else '2 of 3' if len(roots) == 3 else 'Single key'
- vbox.addWidget(QLabel('Type: ' + acctype))
+ vbox.addWidget(QLabel(_('Address type') + ': ' + account.get_type()))
- label = QLabel('Derivation: ' + k)
- vbox.addWidget(label)
+ vbox.addWidget(QLabel(_('Derivation') + ': ' + k))
+
+ vbox.addWidget(QLabel(_('Master Public Key:')))
+
+ text = QTextEdit()
+ text.setReadOnly(True)
+ text.setMaximumHeight(170)
+ vbox.addWidget(text)
- #for root in roots:
- # mpk = self.wallet.master_public_keys[root]
- # text = QTextEdit()
- # text.setReadOnly(True)
- # text.setMaximumHeight(120)
- # text.setText(repr(mpk))
- # vbox.addWidget(text)
+ mpk_text = '\n'.join( account.get_master_pubkeys() )
+ text.setText(mpk_text)
vbox.addLayout(close_button(d))
d.exec_()