gui/qt/main_window.py

   1 #!/usr/bin/env python
   2 #
   3 # Electrum - lightweight Bitcoin client
   4 # Copyright (C) 2012 thomasv@gitorious
   5 #
   6 # This program is free software: you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation, either version 3 of the License, or
   9 # (at your option) any later version.
  10 #
  11 # This program is distributed in the hope that it will be useful,
  12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14 # GNU General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program. If not, see <http://www.gnu.org/licenses/>.
  18
  19 import sys, time, datetime, re, threading
  20 from electrum.i18n import _, set_language
  21 from electrum.util import print_error, print_msg
  22 import os.path, json, ast, traceback
  23 import webbrowser
  24 import shutil
  25 import StringIO
  26
  27
  28 import PyQt4
  29 from PyQt4.QtGui import *
  30 from PyQt4.QtCore import *
  31 import PyQt4.QtCore as QtCore
  32
  33 from electrum.bitcoin import MIN_RELAY_TX_FEE, is_valid
  34 from electrum.plugins import run_hook
  35
  36 import icons_rc
  37
  38 from electrum.wallet import format_satoshis
  39 from electrum import Transaction
  40 from electrum import mnemonic
  41 from electrum import util, bitcoin, commands, Interface, Wallet
  42 from electrum import SimpleConfig, Wallet, WalletStorage
  43
  44 from electrum.paymentrequest import PR_UNPAID, PR_PAID
  45
  46
  47 from electrum import bmp, pyqrnative
  48
  49 from amountedit import AmountEdit, BTCAmountEdit, MyLineEdit
  50 from network_dialog import NetworkDialog
  51 from qrcodewidget import QRCodeWidget
  52
  53 from decimal import Decimal
  54
  55 import platform
  56 import httplib
  57 import socket
  58 import webbrowser
  59 import csv
  60
  61 if platform.system() == 'Windows':
  62     MONOSPACE_FONT = 'Lucida Console'
  63 elif platform.system() == 'Darwin':
  64     MONOSPACE_FONT = 'Monaco'
  65 else:
  66     MONOSPACE_FONT = 'monospace'
  67
  68 from electrum import ELECTRUM_VERSION
  69 import re
  70
  71 from util import *
  72
  73
  74 def format_status(x):
  75     if x == PR_UNPAID:
  76         return _('Unpaid')
  77     elif x == PR_PAID:
  78         return _('Paid')
  79
  80
  81 class StatusBarButton(QPushButton):
  82     def __init__(self, icon, tooltip, func):
  83         QPushButton.__init__(self, icon, '')
  84         self.setToolTip(tooltip)
  85         self.setFlat(True)
  86         self.setMaximumWidth(25)
  87         self.clicked.connect(func)
  88         self.func = func
  89         self.setIconSize(QSize(25,25))
  90
  91     def keyPressEvent(self, e):
  92         if e.key() == QtCore.Qt.Key_Return:
  93             apply(self.func,())
  94
  95
  96
  97
  98
  99
 100
 101
 102
 103
 104 default_column_widths = { "history":[40,140,350,140], "contacts":[350,330], "receive": [370,200,130] }
 105
 106 class ElectrumWindow(QMainWindow):
 107
 108
 109
 110     def __init__(self, config, network, gui_object):
 111         QMainWindow.__init__(self)
 112
 113         self.config = config
 114         self.network = network
 115         self.gui_object = gui_object
 116         self.tray = gui_object.tray
 117         self.go_lite = gui_object.go_lite
 118         self.lite = None
 119
 120         self.create_status_bar()
 121         self.need_update = threading.Event()
 122
 123         self.decimal_point = config.get('decimal_point', 5)
 124         self.num_zeros     = int(config.get('num_zeros',0))
 125         self.invoices      = {}
 126
 127         set_language(config.get('language'))
 128
 129         self.funds_error = False
 130         self.completions = QStringListModel()
 131
 132         self.tabs = tabs = QTabWidget(self)
 133         self.column_widths = self.config.get("column_widths_2", default_column_widths )
 134         tabs.addTab(self.create_history_tab(), _('History') )
 135         tabs.addTab(self.create_send_tab(), _('Send') )
 136         tabs.addTab(self.create_receive_tab(), _('Receive') )
 137         tabs.addTab(self.create_contacts_tab(), _('Contacts') )
 138         tabs.addTab(self.create_invoices_tab(), _('Invoices') )
 139         tabs.addTab(self.create_console_tab(), _('Console') )
 140         tabs.setMinimumSize(600, 400)
 141         tabs.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Expanding)
 142         self.setCentralWidget(tabs)
 143
 144         g = self.config.get("winpos-qt",[100, 100, 840, 400])
 145         self.setGeometry(g[0], g[1], g[2], g[3])
 146         if self.config.get("is_maximized"):
 147             self.showMaximized()
 148
 149         self.setWindowIcon(QIcon(":icons/electrum.png"))
 150         self.init_menubar()
 151
 152         QShortcut(QKeySequence("Ctrl+W"), self, self.close)
 153         QShortcut(QKeySequence("Ctrl+Q"), self, self.close)
 154         QShortcut(QKeySequence("Ctrl+R"), self, self.update_wallet)
 155         QShortcut(QKeySequence("Ctrl+PgUp"), self, lambda: tabs.setCurrentIndex( (tabs.currentIndex() - 1 )%tabs.count() ))
 156         QShortcut(QKeySequence("Ctrl+PgDown"), self, lambda: tabs.setCurrentIndex( (tabs.currentIndex() + 1 )%tabs.count() ))
 157
 158         for i in range(tabs.count()):
 159             QShortcut(QKeySequence("Alt+" + str(i + 1)), self, lambda i=i: tabs.setCurrentIndex(i))
 160
 161         self.connect(self, QtCore.SIGNAL('update_status'), self.update_status)
 162         self.connect(self, QtCore.SIGNAL('banner_signal'), lambda: self.console.showMessage(self.network.banner) )
 163         self.connect(self, QtCore.SIGNAL('transaction_signal'), lambda: self.notify_transactions() )
 164         self.connect(self, QtCore.SIGNAL('payment_request_ok'), self.payment_request_ok)
 165         self.connect(self, QtCore.SIGNAL('payment_request_error'), self.payment_request_error)
 166
 167         self.history_list.setFocus(True)
 168
 169         # network callbacks
 170         if self.network:
 171             self.network.register_callback('updated', lambda: self.need_update.set())
 172             self.network.register_callback('banner', lambda: self.emit(QtCore.SIGNAL('banner_signal')))
 173             self.network.register_callback('disconnected', lambda: self.emit(QtCore.SIGNAL('update_status')))
 174             self.network.register_callback('disconnecting', lambda: self.emit(QtCore.SIGNAL('update_status')))
 175             self.network.register_callback('new_transaction', lambda: self.emit(QtCore.SIGNAL('transaction_signal')))
 176
 177             # set initial message
 178             self.console.showMessage(self.network.banner)
 179
 180         self.wallet = None
 181
 182
 183     def update_account_selector(self):
 184         # account selector
 185         accounts = self.wallet.get_account_names()
 186         self.account_selector.clear()
 187         if len(accounts) > 1:
 188             self.account_selector.addItems([_("All accounts")] + accounts.values())
 189             self.account_selector.setCurrentIndex(0)
 190             self.account_selector.show()
 191         else:
 192             self.account_selector.hide()
 193
 194
 195     def load_wallet(self, wallet):
 196         import electrum
 197
 198         self.wallet = wallet
 199         self.update_wallet_format()
 200
 201         self.invoices = self.wallet.storage.get('invoices', {})
 202         self.accounts_expanded = self.wallet.storage.get('accounts_expanded',{})
 203         self.current_account = self.wallet.storage.get("current_account", None)
 204         title = 'Electrum ' + self.wallet.electrum_version + '  -  ' + self.wallet.storage.path
 205         if self.wallet.is_watching_only(): title += ' [%s]' % (_('watching only'))
 206         self.setWindowTitle( title )
 207         self.update_wallet()
 208         # Once GUI has been initialized check if we want to announce something since the callback has been called before the GUI was initialized
 209         self.notify_transactions()
 210         self.update_account_selector()
 211         # update menus
 212         self.new_account_menu.setEnabled(self.wallet.can_create_accounts())
 213         self.private_keys_menu.setEnabled(not self.wallet.is_watching_only())
 214         self.password_menu.setEnabled(not self.wallet.is_watching_only())
 215         self.seed_menu.setEnabled(self.wallet.has_seed())
 216         self.mpk_menu.setEnabled(self.wallet.is_deterministic())
 217         self.import_menu.setEnabled(self.wallet.can_import())
 218
 219         self.update_lock_icon()
 220         self.update_buttons_on_seed()
 221         self.update_console()
 222
 223         run_hook('load_wallet', wallet)
 224
 225
 226     def update_wallet_format(self):
 227         # convert old-format imported keys
 228         if self.wallet.imported_keys:
 229             password = self.password_dialog(_("Please enter your password in order to update imported keys"))
 230             try:
 231                 self.wallet.convert_imported_keys(password)
 232             except:
 233                 self.show_message("error")
 234
 235
 236     def open_wallet(self):
 237         wallet_folder = self.wallet.storage.path
 238         filename = unicode( QFileDialog.getOpenFileName(self, "Select your wallet file", wallet_folder) )
 239         if not filename:
 240             return
 241
 242         storage = WalletStorage({'wallet_path': filename})
 243         if not storage.file_exists:
 244             self.show_message("file not found "+ filename)
 245             return
 246
 247         self.wallet.stop_threads()
 248
 249         # create new wallet
 250         wallet = Wallet(storage)
 251         wallet.start_threads(self.network)
 252
 253         self.load_wallet(wallet)
 254
 255
 256
 257     def backup_wallet(self):
 258         import shutil
 259         path = self.wallet.storage.path
 260         wallet_folder = os.path.dirname(path)
 261         filename = unicode( QFileDialog.getSaveFileName(self, _('Enter a filename for the copy of your wallet'), wallet_folder) )
 262         if not filename:
 263             return
 264
 265         new_path = os.path.join(wallet_folder, filename)
 266         if new_path != path:
 267             try:
 268                 shutil.copy2(path, new_path)
 269                 QMessageBox.information(None,"Wallet backup created", _("A copy of your wallet file was created in")+" '%s'" % str(new_path))
 270             except (IOError, os.error), reason:
 271                 QMessageBox.critical(None,"Unable to create backup", _("Electrum was unable to copy your wallet file to the specified location.")+"\n" + str(reason))
 272
 273
 274     def new_wallet(self):
 275         import installwizard
 276
 277         wallet_folder = os.path.dirname(self.wallet.storage.path)
 278         filename = unicode( QFileDialog.getSaveFileName(self, _('Enter a new file name'), wallet_folder) )
 279         if not filename:
 280             return
 281         filename = os.path.join(wallet_folder, filename)
 282
 283         storage = WalletStorage({'wallet_path': filename})
 284         if storage.file_exists:
 285             QMessageBox.critical(None, "Error", _("File exists"))
 286             return
 287
 288         wizard = installwizard.InstallWizard(self.config, self.network, storage)
 289         wallet = wizard.run('new')
 290         if wallet:
 291             self.load_wallet(wallet)
 292
 293
 294
 295     def init_menubar(self):
 296         menubar = QMenuBar()
 297
 298         file_menu = menubar.addMenu(_("&File"))
 299         file_menu.addAction(_("&Open"), self.open_wallet).setShortcut(QKeySequence.Open)
 300         file_menu.addAction(_("&New/Restore"), self.new_wallet).setShortcut(QKeySequence.New)
 301         file_menu.addAction(_("&Save Copy"), self.backup_wallet).setShortcut(QKeySequence.SaveAs)
 302         file_menu.addAction(_("&Quit"), self.close)
 303
 304         wallet_menu = menubar.addMenu(_("&Wallet"))
 305         wallet_menu.addAction(_("&New contact"), self.new_contact_dialog)
 306         self.new_account_menu = wallet_menu.addAction(_("&New account"), self.new_account_dialog)
 307
 308         wallet_menu.addSeparator()
 309
 310         self.password_menu = wallet_menu.addAction(_("&Password"), self.change_password_dialog)
 311         self.seed_menu = wallet_menu.addAction(_("&Seed"), self.show_seed_dialog)
 312         self.mpk_menu = wallet_menu.addAction(_("&Master Public Keys"), self.show_master_public_keys)
 313
 314         wallet_menu.addSeparator()
 315         labels_menu = wallet_menu.addMenu(_("&Labels"))
 316         labels_menu.addAction(_("&Import"), self.do_import_labels)
 317         labels_menu.addAction(_("&Export"), self.do_export_labels)
 318
 319         self.private_keys_menu = wallet_menu.addMenu(_("&Private keys"))
 320         self.private_keys_menu.addAction(_("&Sweep"), self.sweep_key_dialog)
 321         self.import_menu = self.private_keys_menu.addAction(_("&Import"), self.do_import_privkey)
 322         self.private_keys_menu.addAction(_("&Export"), self.export_privkeys_dialog)
 323         wallet_menu.addAction(_("&Export History"), self.export_history_dialog)
 324
 325         tools_menu = menubar.addMenu(_("&Tools"))
 326
 327         # Settings / Preferences are all reserved keywords in OSX using this as work around
 328         tools_menu.addAction(_("Electrum preferences") if sys.platform == 'darwin' else _("Preferences"), self.settings_dialog)
 329         tools_menu.addAction(_("&Network"), self.run_network_dialog)
 330         tools_menu.addAction(_("&Plugins"), self.plugins_dialog)
 331         tools_menu.addSeparator()
 332         tools_menu.addAction(_("&Sign/verify message"), self.sign_verify_message)
 333         tools_menu.addAction(_("&Encrypt/decrypt message"), self.encrypt_message)
 334         tools_menu.addSeparator()
 335
 336         csv_transaction_menu = tools_menu.addMenu(_("&Create transaction"))
 337         csv_transaction_menu.addAction(_("&From CSV file"), self.do_process_from_csv_file)
 338         csv_transaction_menu.addAction(_("&From CSV text"), self.do_process_from_csv_text)
 339
 340         raw_transaction_menu = tools_menu.addMenu(_("&Load transaction"))
 341         raw_transaction_menu.addAction(_("&From file"), self.do_process_from_file)
 342         raw_transaction_menu.addAction(_("&From text"), self.do_process_from_text)
 343         raw_transaction_menu.addAction(_("&From the blockchain"), self.do_process_from_txid)
 344
 345         help_menu = menubar.addMenu(_("&Help"))
 346         help_menu.addAction(_("&About"), self.show_about)
 347         help_menu.addAction(_("&Official website"), lambda: webbrowser.open("http://electrum.org"))
 348         help_menu.addSeparator()
 349         help_menu.addAction(_("&Documentation"), lambda: webbrowser.open("http://electrum.org/documentation.html")).setShortcut(QKeySequence.HelpContents)
 350         help_menu.addAction(_("&Report Bug"), self.show_report_bug)
 351
 352         self.setMenuBar(menubar)
 353
 354     def show_about(self):
 355         QMessageBox.about(self, "Electrum",
 356             _("Version")+" %s" % (self.wallet.electrum_version) + "\n\n" + _("Electrum's focus is speed, with low resource usage and simplifying Bitcoin. You do not need to perform regular backups, because your wallet can be recovered from a secret phrase that you can memorize or write on paper. Startup times are instant because it operates in conjunction with high-performance servers that handle the most complicated parts of the Bitcoin system."))
 357
 358     def show_report_bug(self):
 359         QMessageBox.information(self, "Electrum - " + _("Reporting Bugs"),
 360             _("Please report any bugs as issues on github:")+" <a href=\"https://github.com/spesmilo/electrum/issues\">https://github.com/spesmilo/electrum/issues</a>")
 361
 362
 363     def notify_transactions(self):
 364         if not self.network or not self.network.is_connected():
 365             return
 366
 367         print_error("Notifying GUI")
 368         if len(self.network.pending_transactions_for_notifications) > 0:
 369             # Combine the transactions if there are more then three
 370             tx_amount = len(self.network.pending_transactions_for_notifications)
 371             if(tx_amount >= 3):
 372                 total_amount = 0
 373                 for tx in self.network.pending_transactions_for_notifications:
 374                     is_relevant, is_mine, v, fee = self.wallet.get_tx_value(tx)
 375                     if(v > 0):
 376                         total_amount += v
 377
 378                 self.notify(_("%(txs)s new transactions received. Total amount received in the new transactions %(amount)s %(unit)s") \
 379                                 % { 'txs' : tx_amount, 'amount' : self.format_amount(total_amount), 'unit' : self.base_unit()})
 380
 381                 self.network.pending_transactions_for_notifications = []
 382             else:
 383               for tx in self.network.pending_transactions_for_notifications:
 384                   if tx:
 385                       self.network.pending_transactions_for_notifications.remove(tx)
 386                       is_relevant, is_mine, v, fee = self.wallet.get_tx_value(tx)
 387                       if(v > 0):
 388                           self.notify(_("New transaction received. %(amount)s %(unit)s") % { 'amount' : self.format_amount(v), 'unit' : self.base_unit()})
 389
 390     def notify(self, message):
 391         self.tray.showMessage("Electrum", message, QSystemTrayIcon.Information, 20000)
 392
 393
 394
 395     # custom wrappers for getOpenFileName and getSaveFileName, that remember the path selected by the user
 396     def getOpenFileName(self, title, filter = ""):
 397         directory = self.config.get('io_dir', unicode(os.path.expanduser('~')))
 398         fileName = unicode( QFileDialog.getOpenFileName(self, title, directory, filter) )
 399         if fileName and directory != os.path.dirname(fileName):
 400             self.config.set_key('io_dir', os.path.dirname(fileName), True)
 401         return fileName
 402
 403     def getSaveFileName(self, title, filename, filter = ""):
 404         directory = self.config.get('io_dir', unicode(os.path.expanduser('~')))
 405         path = os.path.join( directory, filename )
 406         fileName = unicode( QFileDialog.getSaveFileName(self, title, path, filter) )
 407         if fileName and directory != os.path.dirname(fileName):
 408             self.config.set_key('io_dir', os.path.dirname(fileName), True)
 409         return fileName
 410
 411     def close(self):
 412         QMainWindow.close(self)
 413         run_hook('close_main_window')
 414
 415     def connect_slots(self, sender):
 416         self.connect(sender, QtCore.SIGNAL('timersignal'), self.timer_actions)
 417         self.previous_payto_e=''
 418
 419     def timer_actions(self):
 420         if self.need_update.is_set():
 421             self.update_wallet()
 422             self.need_update.clear()
 423         run_hook('timer_actions')
 424
 425     def format_amount(self, x, is_diff=False, whitespaces=False):
 426         return format_satoshis(x, is_diff, self.num_zeros, self.decimal_point, whitespaces)
 427
 428
 429     def get_decimal_point(self):
 430         return self.decimal_point
 431
 432
 433     def base_unit(self):
 434         assert self.decimal_point in [5,8]
 435         return "BTC" if self.decimal_point == 8 else "mBTC"
 436
 437
 438     def update_status(self):
 439         if self.network is None or not self.network.is_running():
 440             text = _("Offline")
 441             icon = QIcon(":icons/status_disconnected.png")
 442
 443         elif self.network.is_connected():
 444             if not self.wallet.up_to_date:
 445                 text = _("Synchronizing...")
 446                 icon = QIcon(":icons/status_waiting.png")
 447             elif self.network.server_lag > 1:
 448                 text = _("Server is lagging (%d blocks)"%self.network.server_lag)
 449                 icon = QIcon(":icons/status_lagging.png")
 450             else:
 451                 c, u = self.wallet.get_account_balance(self.current_account)
 452                 text =  _( "Balance" ) + ": %s "%( self.format_amount(c) ) + self.base_unit()
 453                 if u: text +=  " [%s unconfirmed]"%( self.format_amount(u,True).strip() )
 454
 455                 # append fiat balance and price from exchange rate plugin
 456                 r = {}
 457                 run_hook('get_fiat_status_text', c+u, r)
 458                 quote = r.get(0)
 459                 if quote:
 460                     text += "%s"%quote
 461
 462                 self.tray.setToolTip(text)
 463                 icon = QIcon(":icons/status_connected.png")
 464         else:
 465             text = _("Not connected")
 466             icon = QIcon(":icons/status_disconnected.png")
 467
 468         self.balance_label.setText(text)
 469         self.status_button.setIcon( icon )
 470
 471
 472     def update_wallet(self):
 473         self.update_status()
 474         if self.wallet.up_to_date or not self.network or not self.network.is_connected():
 475             self.update_history_tab()
 476             self.update_receive_tab()
 477             self.update_contacts_tab()
 478             self.update_completions()
 479             self.update_invoices_tab()
 480
 481
 482     def create_history_tab(self):
 483         self.history_list = l = MyTreeWidget(self)
 484         l.setColumnCount(5)
 485         for i,width in enumerate(self.column_widths['history']):
 486             l.setColumnWidth(i, width)
 487         l.setHeaderLabels( [ '', _('Date'), _('Description') , _('Amount'), _('Balance')] )
 488         self.connect(l, SIGNAL('itemDoubleClicked(QTreeWidgetItem*, int)'), self.tx_label_clicked)
 489         self.connect(l, SIGNAL('itemChanged(QTreeWidgetItem*, int)'), self.tx_label_changed)
 490
 491         l.customContextMenuRequested.connect(self.create_history_menu)
 492         return l
 493
 494
 495     def create_history_menu(self, position):
 496         self.history_list.selectedIndexes()
 497         item = self.history_list.currentItem()
 498         be = self.config.get('block_explorer', 'Blockchain.info')
 499         if be == 'Blockchain.info':
 500             block_explorer = 'https://blockchain.info/tx/'
 501         elif be == 'Blockr.io':
 502             block_explorer = 'https://blockr.io/tx/info/'
 503         elif be == 'Insight.is':
 504             block_explorer = 'http://live.insight.is/tx/'
 505         if not item: return
 506         tx_hash = str(item.data(0, Qt.UserRole).toString())
 507         if not tx_hash: return
 508         menu = QMenu()
 509         menu.addAction(_("Copy ID to Clipboard"), lambda: self.app.clipboard().setText(tx_hash))
 510         menu.addAction(_("Details"), lambda: self.show_transaction(self.wallet.transactions.get(tx_hash)))
 511         menu.addAction(_("Edit description"), lambda: self.tx_label_clicked(item,2))
 512         menu.addAction(_("View on block explorer"), lambda: webbrowser.open(block_explorer + tx_hash))
 513         menu.exec_(self.contacts_list.viewport().mapToGlobal(position))
 514
 515
 516     def show_transaction(self, tx):
 517         import transaction_dialog
 518         d = transaction_dialog.TxDialog(tx, self)
 519         d.exec_()
 520
 521     def tx_label_clicked(self, item, column):
 522         if column==2 and item.isSelected():
 523             self.is_edit=True
 524             item.setFlags(Qt.ItemIsEditable|Qt.ItemIsSelectable | Qt.ItemIsUserCheckable | Qt.ItemIsEnabled | Qt.ItemIsDragEnabled)
 525             self.history_list.editItem( item, column )
 526             item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsUserCheckable | Qt.ItemIsEnabled | Qt.ItemIsDragEnabled)
 527             self.is_edit=False
 528
 529     def tx_label_changed(self, item, column):
 530         if self.is_edit:
 531             return
 532         self.is_edit=True
 533         tx_hash = str(item.data(0, Qt.UserRole).toString())
 534         tx = self.wallet.transactions.get(tx_hash)
 535         text = unicode( item.text(2) )
 536         self.wallet.set_label(tx_hash, text)
 537         if text:
 538             item.setForeground(2, QBrush(QColor('black')))
 539         else:
 540             text = self.wallet.get_default_label(tx_hash)
 541             item.setText(2, text)
 542             item.setForeground(2, QBrush(QColor('gray')))
 543         self.is_edit=False
 544
 545
 546     def edit_label(self, is_recv):
 547         l = self.receive_list if is_recv else self.contacts_list
 548         item = l.currentItem()
 549         item.setFlags(Qt.ItemIsEditable|Qt.ItemIsSelectable | Qt.ItemIsUserCheckable | Qt.ItemIsEnabled | Qt.ItemIsDragEnabled)
 550         l.editItem( item, 1 )
 551         item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsUserCheckable | Qt.ItemIsEnabled | Qt.ItemIsDragEnabled)
 552
 553
 554
 555     def address_label_clicked(self, item, column, l, column_addr, column_label):
 556         if column == column_label and item.isSelected():
 557             is_editable = item.data(0, 32).toBool()
 558             if not is_editable:
 559                 return
 560             addr = unicode( item.text(column_addr) )
 561             label = unicode( item.text(column_label) )
 562             item.setFlags(Qt.ItemIsEditable|Qt.ItemIsSelectable | Qt.ItemIsUserCheckable | Qt.ItemIsEnabled | Qt.ItemIsDragEnabled)
 563             l.editItem( item, column )
 564             item.setFlags(Qt.ItemIsSelectable | Qt.ItemIsUserCheckable | Qt.ItemIsEnabled | Qt.ItemIsDragEnabled)
 565
 566
 567     def address_label_changed(self, item, column, l, column_addr, column_label):
 568         if column == column_label:
 569             addr = unicode( item.text(column_addr) )
 570             text = unicode( item.text(column_label) )
 571             is_editable = item.data(0, 32).toBool()
 572             if not is_editable:
 573                 return
 574
 575             changed = self.wallet.set_label(addr, text)
 576             if changed:
 577                 self.update_history_tab()
 578                 self.update_completions()
 579
 580             self.current_item_changed(item)
 581
 582         run_hook('item_changed', item, column)
 583
 584
 585     def current_item_changed(self, a):
 586         run_hook('current_item_changed', a)
 587
 588
 589
 590     def update_history_tab(self):
 591
 592         self.history_list.clear()
 593         for item in self.wallet.get_tx_history(self.current_account):
 594             tx_hash, conf, is_mine, value, fee, balance, timestamp = item
 595             time_str = _("unknown")
 596             if conf > 0:
 597                 try:
 598                     time_str = datetime.datetime.fromtimestamp( timestamp).isoformat(' ')[:-3]
 599                 except Exception:
 600                     time_str = _("error")
 601
 602             if conf == -1:
 603                 time_str = 'unverified'
 604                 icon = QIcon(":icons/unconfirmed.png")
 605             elif conf == 0:
 606                 time_str = 'pending'
 607                 icon = QIcon(":icons/unconfirmed.png")
 608             elif conf < 6:
 609                 icon = QIcon(":icons/clock%d.png"%conf)
 610             else:
 611                 icon = QIcon(":icons/confirmed.png")
 612
 613             if value is not None:
 614                 v_str = self.format_amount(value, True, whitespaces=True)
 615             else:
 616                 v_str = '--'
 617
 618             balance_str = self.format_amount(balance, whitespaces=True)
 619
 620             if tx_hash:
 621                 label, is_default_label = self.wallet.get_label(tx_hash)
 622             else:
 623                 label = _('Pruned transaction outputs')
 624                 is_default_label = False
 625
 626             item = QTreeWidgetItem( [ '', time_str, label, v_str, balance_str] )
 627             item.setFont(2, QFont(MONOSPACE_FONT))
 628             item.setFont(3, QFont(MONOSPACE_FONT))
 629             item.setFont(4, QFont(MONOSPACE_FONT))
 630             if value < 0:
 631                 item.setForeground(3, QBrush(QColor("#BC1E1E")))
 632             if tx_hash:
 633                 item.setData(0, Qt.UserRole, tx_hash)
 634                 item.setToolTip(0, "%d %s\nTxId:%s" % (conf, _('Confirmations'), tx_hash) )
 635             if is_default_label:
 636                 item.setForeground(2, QBrush(QColor('grey')))
 637
 638             item.setIcon(0, icon)
 639             self.history_list.insertTopLevelItem(0,item)
 640
 641
 642         self.history_list.setCurrentItem(self.history_list.topLevelItem(0))
 643         run_hook('history_tab_update')
 644
 645
 646     def create_send_tab(self):
 647         w = QWidget()
 648
 649         self.send_grid = grid = QGridLayout(w)
 650         grid.setSpacing(8)
 651         grid.setColumnMinimumWidth(3,300)
 652         grid.setColumnStretch(5,1)
 653         grid.setRowStretch(8, 1)
 654
 655         from paytoedit import PayToEdit
 656         self.amount_e = BTCAmountEdit(self.get_decimal_point)
 657         self.payto_e = PayToEdit(self.amount_e)
 658         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)'))
 659         grid.addWidget(QLabel(_('Pay to')), 1, 0)
 660         grid.addWidget(self.payto_e, 1, 1, 1, 3)
 661         grid.addWidget(self.payto_help, 1, 4)
 662
 663         completer = QCompleter()
 664         completer.setCaseSensitivity(False)
 665         self.payto_e.setCompleter(completer)
 666         completer.setModel(self.completions)
 667
 668         self.message_e = MyLineEdit()
 669         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.'))
 670         grid.addWidget(QLabel(_('Description')), 2, 0)
 671         grid.addWidget(self.message_e, 2, 1, 1, 3)
 672         grid.addWidget(self.message_help, 2, 4)
 673
 674         self.from_label = QLabel(_('From'))
 675         grid.addWidget(self.from_label, 3, 0)
 676         self.from_list = MyTreeWidget(self)
 677         self.from_list.setColumnCount(2)
 678         self.from_list.setColumnWidth(0, 350)
 679         self.from_list.setColumnWidth(1, 50)
 680         self.from_list.setHeaderHidden(True)
 681         self.from_list.setMaximumHeight(80)
 682         self.from_list.setContextMenuPolicy(Qt.CustomContextMenu)
 683         self.from_list.customContextMenuRequested.connect(self.from_list_menu)
 684         grid.addWidget(self.from_list, 3, 1, 1, 3)
 685         self.set_pay_from([])
 686
 687         self.amount_help = HelpButton(_('Amount to be sent.') + '\n\n' \
 688                                       + _('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.') \
 689                                       + '\n\n' + _('Keyboard shortcut: type "!" to send all your coins.'))
 690         grid.addWidget(QLabel(_('Amount')), 4, 0)
 691         grid.addWidget(self.amount_e, 4, 1, 1, 2)
 692         grid.addWidget(self.amount_help, 4, 3)
 693
 694         self.fee_e = BTCAmountEdit(self.get_decimal_point)
 695         grid.addWidget(QLabel(_('Fee')), 5, 0)
 696         grid.addWidget(self.fee_e, 5, 1, 1, 2)
 697         grid.addWidget(HelpButton(
 698                 _('Bitcoin transactions are in general not free. A transaction fee is paid by the sender of the funds.') + '\n\n'\
 699                     + _('The amount of fee can be decided freely by the sender. However, transactions with low fees take more time to be processed.') + '\n\n'\
 700                     + _('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)
 701
 702         self.send_button = EnterButton(_("Send"), self.do_send)
 703         grid.addWidget(self.send_button, 6, 1)
 704
 705         b = EnterButton(_("Clear"), self.do_clear)
 706         grid.addWidget(b, 6, 2)
 707
 708         self.payto_sig = QLabel('')
 709         grid.addWidget(self.payto_sig, 7, 0, 1, 4)
 710
 711         #QShortcut(QKeySequence("Up"), w, w.focusPreviousChild)
 712         #QShortcut(QKeySequence("Down"), w, w.focusNextChild)
 713         w.setLayout(grid)
 714
 715         def entry_changed( is_fee ):
 716             self.funds_error = False
 717
 718             if self.amount_e.is_shortcut:
 719                 self.amount_e.is_shortcut = False
 720                 sendable = self.get_sendable_balance()
 721                 # there is only one output because we are completely spending inputs
 722                 inputs, total, fee = self.wallet.choose_tx_inputs( sendable, 0, 1, coins = self.get_coins())
 723                 fee = self.wallet.estimated_fee(inputs, 1)
 724                 amount = total - fee
 725                 self.amount_e.setAmount(amount)
 726                 self.fee_e.setAmount(fee)
 727                 return
 728
 729             amount = self.amount_e.get_amount()
 730             fee = self.fee_e.get_amount()
 731
 732             if not is_fee: fee = None
 733             if amount is None:
 734                 return
 735             # assume that there will be 2 outputs (one for change)
 736             inputs, total, fee = self.wallet.choose_tx_inputs(amount, fee, 2, coins = self.get_coins())
 737             if not is_fee:
 738                 self.fee_e.setAmount(fee)
 739             if inputs:
 740                 palette = QPalette()
 741                 palette.setColor(self.amount_e.foregroundRole(), QColor('black'))
 742                 text = ""
 743             else:
 744                 palette = QPalette()
 745                 palette.setColor(self.amount_e.foregroundRole(), QColor('red'))
 746                 self.funds_error = True
 747                 text = _( "Not enough funds" )
 748                 c, u = self.wallet.get_frozen_balance()
 749                 if c+u: text += ' (' + self.format_amount(c+u).strip() + ' ' + self.base_unit() + ' ' +_("are frozen") + ')'
 750
 751             self.statusBar().showMessage(text)
 752             self.amount_e.setPalette(palette)
 753             self.fee_e.setPalette(palette)
 754
 755         self.amount_e.textChanged.connect(lambda: entry_changed(False) )
 756         self.fee_e.textChanged.connect(lambda: entry_changed(True) )
 757
 758         run_hook('create_send_tab', grid)
 759         return w
 760
 761     def from_list_delete(self, item):
 762         i = self.from_list.indexOfTopLevelItem(item)
 763         self.pay_from.pop(i)
 764         self.redraw_from_list()
 765
 766     def from_list_menu(self, position):
 767         item = self.from_list.itemAt(position)
 768         menu = QMenu()
 769         menu.addAction(_("Remove"), lambda: self.from_list_delete(item))
 770         menu.exec_(self.from_list.viewport().mapToGlobal(position))
 771
 772     def set_pay_from(self, domain = None):
 773         self.pay_from = [] if domain == [] else self.wallet.get_unspent_coins(domain)
 774         self.redraw_from_list()
 775
 776     def redraw_from_list(self):
 777         self.from_list.clear()
 778         self.from_label.setHidden(len(self.pay_from) == 0)
 779         self.from_list.setHidden(len(self.pay_from) == 0)
 780
 781         def format(x):
 782             h = x.get('prevout_hash')
 783             return h[0:8] + '...' + h[-8:] + ":%d"%x.get('prevout_n') + u'\t' + "%s"%x.get('address')
 784
 785         for item in self.pay_from:
 786             self.from_list.addTopLevelItem(QTreeWidgetItem( [format(item), self.format_amount(item['value']) ]))
 787
 788     def update_completions(self):
 789         l = []
 790         for addr,label in self.wallet.labels.items():
 791             if addr in self.wallet.addressbook:
 792                 l.append( label + '  <' + addr + '>')
 793
 794         run_hook('update_completions', l)
 795         self.completions.setStringList(l)
 796
 797
 798     def protected(func):
 799         return lambda s, *args: s.do_protect(func, args)
 800
 801
 802     def do_send(self):
 803         label = unicode( self.message_e.text() )
 804
 805         if self.gui_object.payment_request:
 806             outputs = self.gui_object.payment_request.get_outputs()
 807         else:
 808             outputs = self.payto_e.get_outputs()
 809
 810         if not outputs:
 811             QMessageBox.warning(self, _('Error'), _('No outputs'), _('OK'))
 812             return
 813
 814         for addr, x in outputs:
 815             if addr is None or not bitcoin.is_address(addr):
 816                 QMessageBox.warning(self, _('Error'), _('Invalid Bitcoin Address'), _('OK'))
 817                 return
 818             if x is None:
 819                 QMessageBox.warning(self, _('Error'), _('Invalid Amount'), _('OK'))
 820                 return
 821
 822         amount = sum(map(lambda x:x[1], outputs))
 823
 824         fee = self.fee_e.get_amount()
 825         if fee is None:
 826             QMessageBox.warning(self, _('Error'), _('Invalid Fee'), _('OK'))
 827             return
 828
 829         confirm_amount = self.config.get('confirm_amount', 100000000)
 830         if amount >= confirm_amount:
 831             o = '\n'.join(map(lambda x:x[0], outputs))
 832             if not self.question(_("send %(amount)s to %(address)s?")%{ 'amount' : self.format_amount(amount) + ' '+ self.base_unit(), 'address' : o}):
 833                 return
 834
 835         confirm_fee = self.config.get('confirm_fee', 100000)
 836         if fee >= confirm_fee:
 837             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()}):
 838                 return
 839
 840         self.send_tx(outputs, fee, label)
 841
 842
 843
 844     @protected
 845     def send_tx(self, outputs, fee, label, password):
 846         self.send_button.setDisabled(True)
 847
 848         # first, create an unsigned tx
 849         coins = self.get_coins()
 850         try:
 851             tx = self.wallet.make_unsigned_transaction(outputs, fee, None, coins = coins)
 852             tx.error = None
 853         except Exception as e:
 854             traceback.print_exc(file=sys.stdout)
 855             self.show_message(str(e))
 856             self.send_button.setDisabled(False)
 857             return
 858
 859         # call hook to see if plugin needs gui interaction
 860         run_hook('send_tx', tx)
 861
 862         # sign the tx
 863         def sign_thread():
 864             time.sleep(0.1)
 865             keypairs = {}
 866             self.wallet.add_keypairs_from_wallet(tx, keypairs, password)
 867             self.wallet.sign_transaction(tx, keypairs, password)
 868             return tx, fee, label
 869
 870         def sign_done(tx, fee, label):
 871             if tx.error:
 872                 self.show_message(tx.error)
 873                 self.send_button.setDisabled(False)
 874                 return
 875             if tx.requires_fee(self.wallet.verifier) and fee < MIN_RELAY_TX_FEE:
 876                 QMessageBox.warning(self, _('Error'), _("This transaction requires a higher fee, or it will not be propagated by the network."), _('OK'))
 877                 self.send_button.setDisabled(False)
 878                 return
 879             if label:
 880                 self.wallet.set_label(tx.hash(), label)
 881
 882             if not tx.is_complete() or self.config.get('show_before_broadcast'):
 883                 self.show_transaction(tx)
 884                 self.do_clear()
 885                 self.send_button.setDisabled(False)
 886                 return
 887
 888             self.broadcast_transaction(tx)
 889
 890         self.waiting_dialog = WaitingDialog(self, 'Signing..', sign_thread, sign_done)
 891         self.waiting_dialog.start()
 892
 893
 894
 895     def broadcast_transaction(self, tx):
 896
 897         def broadcast_thread():
 898             pr = self.gui_object.payment_request
 899             if pr is None:
 900                 return self.wallet.sendtx(tx)
 901
 902             if pr.has_expired():
 903                 self.gui_object.payment_request = None
 904                 return False, _("Payment request has expired")
 905
 906             status, msg =  self.wallet.sendtx(tx)
 907             if not status:
 908                 return False, msg
 909
 910             self.invoices[pr.get_id()] = (pr.get_domain(), pr.get_memo(), pr.get_amount(), PR_PAID, tx.hash())
 911             self.wallet.storage.put('invoices', self.invoices)
 912             self.update_invoices_tab()
 913             self.gui_object.payment_request = None
 914             refund_address = self.wallet.addresses()[0]
 915             ack_status, ack_msg = pr.send_ack(str(tx), refund_address)
 916             if ack_status:
 917                 msg = ack_msg
 918
 919             return status, msg
 920
 921         def broadcast_done(status, msg):
 922             if status:
 923                 QMessageBox.information(self, '', _('Payment sent.') + '\n' + msg, _('OK'))
 924                 self.do_clear()
 925             else:
 926                 QMessageBox.warning(self, _('Error'), msg, _('OK'))
 927             self.send_button.setDisabled(False)
 928
 929         self.waiting_dialog = WaitingDialog(self, 'Broadcasting..', broadcast_thread, broadcast_done)
 930         self.waiting_dialog.start()
 931
 932
 933
 934     def prepare_for_payment_request(self):
 935         self.tabs.setCurrentIndex(1)
 936         self.payto_e.is_pr = True
 937         for e in [self.payto_e, self.amount_e, self.message_e]:
 938             e.setFrozen(True)
 939         for h in [self.payto_help, self.amount_help, self.message_help]:
 940             h.hide()
 941         self.payto_e.setText(_("please wait..."))
 942         return True
 943
 944     def payment_request_ok(self):
 945         pr = self.gui_object.payment_request
 946         pr_id = pr.get_id()
 947         if pr_id not in self.invoices:
 948             self.invoices[pr_id] = (pr.get_domain(), pr.get_memo(), pr.get_amount(), PR_UNPAID, None)
 949             self.wallet.storage.put('invoices', self.invoices)
 950             self.update_invoices_tab()
 951         else:
 952             print_error('invoice already in list')
 953
 954         status = self.invoices[pr_id][3]
 955         if status == PR_PAID:
 956             self.do_clear()
 957             self.show_message("invoice already paid")
 958             self.gui_object.payment_request = None
 959             return
 960
 961         self.payto_help.show()
 962         self.payto_help.set_alt(lambda: self.show_pr_details(pr))
 963
 964         self.payto_e.setGreen()
 965         self.payto_e.setText(pr.domain)
 966         self.amount_e.setText(self.format_amount(pr.get_amount()))
 967         self.message_e.setText(pr.get_memo())
 968
 969     def payment_request_error(self):
 970         self.do_clear()
 971         self.show_message(self.gui_object.payment_request.error)
 972         self.gui_object.payment_request = None
 973
 974     def set_send(self, address, amount, label, message):
 975
 976         if label and self.wallet.labels.get(address) != label:
 977             if self.question('Give label "%s" to address %s ?'%(label,address)):
 978                 if address not in self.wallet.addressbook and not self.wallet.is_mine(address):
 979                     self.wallet.addressbook.append(address)
 980                 self.wallet.set_label(address, label)
 981
 982         self.tabs.setCurrentIndex(1)
 983         label = self.wallet.labels.get(address)
 984         m_addr = label + '  <'+ address +'>' if label else address
 985         self.payto_e.setText(m_addr)
 986
 987         self.message_e.setText(message)
 988         if amount:
 989             self.amount_e.setText(amount)
 990
 991
 992     def do_clear(self):
 993         self.payto_e.is_pr = False
 994         self.payto_sig.setVisible(False)
 995         for e in [self.payto_e, self.message_e, self.amount_e, self.fee_e]:
 996             e.setText('')
 997             e.setFrozen(False)
 998
 999         for h in [self.payto_help, self.amount_help, self.message_help]:
1000             h.show()
1001
1002         self.payto_help.set_alt(None)
1003         self.set_pay_from([])
1004         self.update_status()
1005
1006
1007
1008     def set_addrs_frozen(self,addrs,freeze):
1009         for addr in addrs:
1010             if not addr: continue
1011             if addr in self.wallet.frozen_addresses and not freeze:
1012                 self.wallet.unfreeze(addr)
1013             elif addr not in self.wallet.frozen_addresses and freeze:
1014                 self.wallet.freeze(addr)
1015         self.update_receive_tab()
1016
1017
1018
1019     def create_list_tab(self, headers):
1020         "generic tab creation method"
1021         l = MyTreeWidget(self)
1022         l.setColumnCount( len(headers) )
1023         l.setHeaderLabels( headers )
1024
1025         w = QWidget()
1026         vbox = QVBoxLayout()
1027         w.setLayout(vbox)
1028
1029         vbox.setMargin(0)
1030         vbox.setSpacing(0)
1031         vbox.addWidget(l)
1032         buttons = QWidget()
1033         vbox.addWidget(buttons)
1034
1035         return l, w
1036
1037
1038     def create_receive_tab(self):
1039         l, w = self.create_list_tab([ _('Address'), _('Label'), _('Balance'), _('Tx')])
1040         l.setContextMenuPolicy(Qt.CustomContextMenu)
1041         l.customContextMenuRequested.connect(self.create_receive_menu)
1042         l.setSelectionMode(QAbstractItemView.ExtendedSelection)
1043         self.connect(l, SIGNAL('itemDoubleClicked(QTreeWidgetItem*, int)'), lambda a, b: self.address_label_clicked(a,b,l,0,1))
1044         self.connect(l, SIGNAL('itemChanged(QTreeWidgetItem*, int)'), lambda a,b: self.address_label_changed(a,b,l,0,1))
1045         self.connect(l, SIGNAL('currentItemChanged(QTreeWidgetItem*, QTreeWidgetItem*)'), lambda a,b: self.current_item_changed(a))
1046         self.receive_list = l
1047         return w
1048
1049
1050
1051
1052     def save_column_widths(self):
1053         self.column_widths["receive"] = []
1054         for i in range(self.receive_list.columnCount() -1):
1055             self.column_widths["receive"].append(self.receive_list.columnWidth(i))
1056
1057         self.column_widths["history"] = []
1058         for i in range(self.history_list.columnCount() - 1):
1059             self.column_widths["history"].append(self.history_list.columnWidth(i))
1060
1061         self.column_widths["contacts"] = []
1062         for i in range(self.contacts_list.columnCount() - 1):
1063             self.column_widths["contacts"].append(self.contacts_list.columnWidth(i))
1064
1065         self.config.set_key("column_widths_2", self.column_widths, True)
1066
1067
1068     def create_contacts_tab(self):
1069         l, w = self.create_list_tab([_('Address'), _('Label'), _('Tx')])
1070         l.setContextMenuPolicy(Qt.CustomContextMenu)
1071         l.customContextMenuRequested.connect(self.create_contact_menu)
1072         for i,width in enumerate(self.column_widths['contacts']):
1073             l.setColumnWidth(i, width)
1074
1075         self.connect(l, SIGNAL('itemDoubleClicked(QTreeWidgetItem*, int)'), lambda a, b: self.address_label_clicked(a,b,l,0,1))
1076         self.connect(l, SIGNAL('itemChanged(QTreeWidgetItem*, int)'), lambda a,b: self.address_label_changed(a,b,l,0,1))
1077         self.contacts_list = l
1078         return w
1079
1080
1081     def create_invoices_tab(self):
1082         l, w = self.create_list_tab([_('Requestor'), _('Memo'),_('Amount'), _('Status')])
1083         h = l.header()
1084         h.setStretchLastSection(False)
1085         h.setResizeMode(1, QHeaderView.Stretch)
1086         l.setContextMenuPolicy(Qt.CustomContextMenu)
1087         l.customContextMenuRequested.connect(self.create_invoice_menu)
1088         self.invoices_list = l
1089         return w
1090
1091     def update_invoices_tab(self):
1092         invoices = self.wallet.storage.get('invoices', {})
1093         l = self.invoices_list
1094         l.clear()
1095         for key, value in invoices.items():
1096             try:
1097                 domain, memo, amount, status, tx_hash = value
1098             except:
1099                 invoices.pop(key)
1100                 continue
1101             item = QTreeWidgetItem( [ domain, memo, self.format_amount(amount), format_status(status)] )
1102             l.addTopLevelItem(item)
1103
1104         l.setCurrentItem(l.topLevelItem(0))
1105
1106
1107
1108     def delete_imported_key(self, addr):
1109         if self.question(_("Do you want to remove")+" %s "%addr +_("from your wallet?")):
1110             self.wallet.delete_imported_key(addr)
1111             self.update_receive_tab()
1112             self.update_history_tab()
1113
1114     def edit_account_label(self, k):
1115         text, ok = QInputDialog.getText(self, _('Rename account'), _('Name') + ':', text = self.wallet.labels.get(k,''))
1116         if ok:
1117             label = unicode(text)
1118             self.wallet.set_label(k,label)
1119             self.update_receive_tab()
1120
1121     def account_set_expanded(self, item, k, b):
1122         item.setExpanded(b)
1123         self.accounts_expanded[k] = b
1124
1125     def create_account_menu(self, position, k, item):
1126         menu = QMenu()
1127         if item.isExpanded():
1128             menu.addAction(_("Minimize"), lambda: self.account_set_expanded(item, k, False))
1129         else:
1130             menu.addAction(_("Maximize"), lambda: self.account_set_expanded(item, k, True))
1131         menu.addAction(_("Rename"), lambda: self.edit_account_label(k))
1132         if self.wallet.seed_version > 4:
1133             menu.addAction(_("View details"), lambda: self.show_account_details(k))
1134         if self.wallet.account_is_pending(k):
1135             menu.addAction(_("Delete"), lambda: self.delete_pending_account(k))
1136         menu.exec_(self.receive_list.viewport().mapToGlobal(position))
1137
1138     def delete_pending_account(self, k):
1139         self.wallet.delete_pending_account(k)
1140         self.update_receive_tab()
1141
1142     def create_receive_menu(self, position):
1143         # fixme: this function apparently has a side effect.
1144         # if it is not called the menu pops up several times
1145         #self.receive_list.selectedIndexes()
1146
1147         selected = self.receive_list.selectedItems()
1148         multi_select = len(selected) > 1
1149         addrs = [unicode(item.text(0)) for item in selected]
1150         if not multi_select:
1151             item = self.receive_list.itemAt(position)
1152             if not item: return
1153
1154             addr = addrs[0]
1155             if not is_valid(addr):
1156                 k = str(item.data(0,32).toString())
1157                 if k:
1158                     self.create_account_menu(position, k, item)
1159                 else:
1160                     item.setExpanded(not item.isExpanded())
1161                 return
1162
1163         menu = QMenu()
1164         if not multi_select:
1165             menu.addAction(_("Copy to clipboard"), lambda: self.app.clipboard().setText(addr))
1166             menu.addAction(_("QR code"), lambda: self.show_qrcode("bitcoin:" + addr, _("Address")) )
1167             menu.addAction(_("Edit label"), lambda: self.edit_label(True))
1168             menu.addAction(_("Public keys"), lambda: self.show_public_keys(addr))
1169             if not self.wallet.is_watching_only():
1170                 menu.addAction(_("Private key"), lambda: self.show_private_key(addr))
1171                 menu.addAction(_("Sign/verify message"), lambda: self.sign_verify_message(addr))
1172                 menu.addAction(_("Encrypt/decrypt message"), lambda: self.encrypt_message(addr))
1173             if self.wallet.is_imported(addr):
1174                 menu.addAction(_("Remove from wallet"), lambda: self.delete_imported_key(addr))
1175
1176         if any(addr not in self.wallet.frozen_addresses for addr in addrs):
1177             menu.addAction(_("Freeze"), lambda: self.set_addrs_frozen(addrs, True))
1178         if any(addr in self.wallet.frozen_addresses for addr in addrs):
1179             menu.addAction(_("Unfreeze"), lambda: self.set_addrs_frozen(addrs, False))
1180
1181         if any(addr not in self.wallet.frozen_addresses for addr in addrs):
1182             menu.addAction(_("Send From"), lambda: self.send_from_addresses(addrs))
1183
1184         run_hook('receive_menu', menu, addrs)
1185         menu.exec_(self.receive_list.viewport().mapToGlobal(position))
1186
1187
1188     def get_sendable_balance(self):
1189         return sum(map(lambda x:x['value'], self.get_coins()))
1190
1191
1192     def get_coins(self):
1193         if self.pay_from:
1194             return self.pay_from
1195         else:
1196             domain = self.wallet.get_account_addresses(self.current_account)
1197             for i in self.wallet.frozen_addresses:
1198                 if i in domain: domain.remove(i)
1199             return self.wallet.get_unspent_coins(domain)
1200
1201
1202     def send_from_addresses(self, addrs):
1203         self.set_pay_from( addrs )
1204         self.tabs.setCurrentIndex(1)
1205
1206
1207     def payto(self, addr):
1208         if not addr: return
1209         label = self.wallet.labels.get(addr)
1210         m_addr = label + '  <' + addr + '>' if label else addr
1211         self.tabs.setCurrentIndex(1)
1212         self.payto_e.setText(m_addr)
1213         self.amount_e.setFocus()
1214
1215
1216     def delete_contact(self, x):
1217         if self.question(_("Do you want to remove")+" %s "%x +_("from your list of contacts?")):
1218             self.wallet.delete_contact(x)
1219             self.wallet.set_label(x, None)
1220             self.update_history_tab()
1221             self.update_contacts_tab()
1222             self.update_completions()
1223
1224
1225     def create_contact_menu(self, position):
1226         item = self.contacts_list.itemAt(position)
1227         menu = QMenu()
1228         if not item:
1229             menu.addAction(_("New contact"), lambda: self.new_contact_dialog())
1230         else:
1231             addr = unicode(item.text(0))
1232             label = unicode(item.text(1))
1233             is_editable = item.data(0,32).toBool()
1234             payto_addr = item.data(0,33).toString()
1235             menu.addAction(_("Copy to Clipboard"), lambda: self.app.clipboard().setText(addr))
1236             menu.addAction(_("Pay to"), lambda: self.payto(payto_addr))
1237             menu.addAction(_("QR code"), lambda: self.show_qrcode("bitcoin:" + addr, _("Address")))
1238             if is_editable:
1239                 menu.addAction(_("Edit label"), lambda: self.edit_label(False))
1240                 menu.addAction(_("Delete"), lambda: self.delete_contact(addr))
1241
1242         run_hook('create_contact_menu', menu, item)
1243         menu.exec_(self.contacts_list.viewport().mapToGlobal(position))
1244
1245     def delete_invoice(self, key):
1246         self.invoices.pop(key)
1247         self.wallet.storage.put('invoices', self.invoices)
1248         self.update_invoices_tab()
1249
1250     def show_invoice(self, key):
1251         from electrum.paymentrequest import PaymentRequest
1252         domain, memo, value, status, tx_hash = self.invoices[key]
1253         pr = PaymentRequest(self.config)
1254         pr.read_file(key)
1255         pr.domain = domain
1256         pr.verify()
1257         self.show_pr_details(pr)
1258
1259     def show_pr_details(self, pr):
1260         msg = 'Domain: ' + pr.domain
1261         msg += '\nStatus: ' + pr.get_status()
1262         msg += '\nMemo: ' + pr.get_memo()
1263         msg += '\nPayment URL: ' + pr.payment_url
1264         msg += '\n\nOutputs:\n' + '\n'.join(map(lambda x: x[0] + ' ' + self.format_amount(x[1])+ self.base_unit(), pr.get_outputs()))
1265         QMessageBox.information(self, 'Invoice', msg , 'OK')
1266
1267     def create_invoice_menu(self, position):
1268         item = self.invoices_list.itemAt(position)
1269         if not item:
1270             return
1271         k = self.invoices_list.indexOfTopLevelItem(item)
1272         key = self.invoices.keys()[k]
1273         menu = QMenu()
1274         menu.addAction(_("Details"), lambda: self.show_invoice(key))
1275         menu.addAction(_("Delete"), lambda: self.delete_invoice(key))
1276         menu.exec_(self.invoices_list.viewport().mapToGlobal(position))
1277
1278
1279     def update_receive_item(self, item):
1280         item.setFont(0, QFont(MONOSPACE_FONT))
1281         address = str(item.data(0,0).toString())
1282         label = self.wallet.labels.get(address,'')
1283         item.setData(1,0,label)
1284         item.setData(0,32, True) # is editable
1285
1286         run_hook('update_receive_item', address, item)
1287
1288         if not self.wallet.is_mine(address): return
1289
1290         c, u = self.wallet.get_addr_balance(address)
1291         balance = self.format_amount(c + u)
1292         item.setData(2,0,balance)
1293
1294         if address in self.wallet.frozen_addresses:
1295             item.setBackgroundColor(0, QColor('lightblue'))
1296
1297
1298     def update_receive_tab(self):
1299         l = self.receive_list
1300         # extend the syntax for consistency
1301         l.addChild = l.addTopLevelItem
1302         l.insertChild = l.insertTopLevelItem
1303
1304         l.clear()
1305         for i,width in enumerate(self.column_widths['receive']):
1306             l.setColumnWidth(i, width)
1307
1308         accounts = self.wallet.get_accounts()
1309         if self.current_account is None:
1310             account_items = sorted(accounts.items())
1311         else:
1312             account_items = [(self.current_account, accounts.get(self.current_account))]
1313
1314
1315         for k, account in account_items:
1316
1317             if len(accounts) > 1:
1318                 name = self.wallet.get_account_name(k)
1319                 c,u = self.wallet.get_account_balance(k)
1320                 account_item = QTreeWidgetItem( [ name, '', self.format_amount(c+u), ''] )
1321                 l.addTopLevelItem(account_item)
1322                 account_item.setExpanded(self.accounts_expanded.get(k, True))
1323                 account_item.setData(0, 32, k)
1324             else:
1325                 account_item = l
1326
1327             sequences = [0,1] if account.has_change() else [0]
1328             for is_change in sequences:
1329                 if len(sequences) > 1:
1330                     name = _("Receiving") if not is_change else _("Change")
1331                     seq_item = QTreeWidgetItem( [ name, '', '', '', ''] )
1332                     account_item.addChild(seq_item)
1333                     if not is_change:
1334                         seq_item.setExpanded(True)
1335                 else:
1336                     seq_item = account_item
1337
1338                 used_item = QTreeWidgetItem( [ _("Used"), '', '', '', ''] )
1339                 used_flag = False
1340
1341                 is_red = False
1342                 gap = 0
1343
1344                 for address in account.get_addresses(is_change):
1345
1346                     num, is_used = self.wallet.is_used(address)
1347                     if num == 0:
1348                         gap += 1
1349                         if gap > self.wallet.gap_limit:
1350                             is_red = True
1351                     else:
1352                         gap = 0
1353
1354                     item = QTreeWidgetItem( [ address, '', '', "%d"%num] )
1355                     self.update_receive_item(item)
1356                     if is_red:
1357                         item.setBackgroundColor(1, QColor('red'))
1358
1359                     if is_used:
1360                         if not used_flag:
1361                             seq_item.insertChild(0,used_item)
1362                             used_flag = True
1363                         used_item.addChild(item)
1364                     else:
1365                         seq_item.addChild(item)
1366
1367         # we use column 1 because column 0 may be hidden
1368         l.setCurrentItem(l.topLevelItem(0),1)
1369
1370
1371     def update_contacts_tab(self):
1372         l = self.contacts_list
1373         l.clear()
1374
1375         for address in self.wallet.addressbook:
1376             label = self.wallet.labels.get(address,'')
1377             n = self.wallet.get_num_tx(address)
1378             item = QTreeWidgetItem( [ address, label, "%d"%n] )
1379             item.setFont(0, QFont(MONOSPACE_FONT))
1380             # 32 = label can be edited (bool)
1381             item.setData(0,32, True)
1382             # 33 = payto string
1383             item.setData(0,33, address)
1384             l.addTopLevelItem(item)
1385
1386         run_hook('update_contacts_tab', l)
1387         l.setCurrentItem(l.topLevelItem(0))
1388
1389
1390
1391     def create_console_tab(self):
1392         from console import Console
1393         self.console = console = Console()
1394         return console
1395
1396
1397     def update_console(self):
1398         console = self.console
1399         console.history = self.config.get("console-history",[])
1400         console.history_index = len(console.history)
1401
1402         console.updateNamespace({'wallet' : self.wallet, 'network' : self.network, 'gui':self})
1403         console.updateNamespace({'util' : util, 'bitcoin':bitcoin})
1404
1405         c = commands.Commands(self.wallet, self.network, lambda: self.console.set_json(True))
1406         methods = {}
1407         def mkfunc(f, method):
1408             return lambda *args: apply( f, (method, args, self.password_dialog ))
1409         for m in dir(c):
1410             if m[0]=='_' or m in ['network','wallet']: continue
1411             methods[m] = mkfunc(c._run, m)
1412
1413         console.updateNamespace(methods)
1414
1415
1416     def change_account(self,s):
1417         if s == _("All accounts"):
1418             self.current_account = None
1419         else:
1420             accounts = self.wallet.get_account_names()
1421             for k, v in accounts.items():
1422                 if v == s:
1423                     self.current_account = k
1424         self.update_history_tab()
1425         self.update_status()
1426         self.update_receive_tab()
1427
1428     def create_status_bar(self):
1429
1430         sb = QStatusBar()
1431         sb.setFixedHeight(35)
1432         qtVersion = qVersion()
1433
1434         self.balance_label = QLabel("")
1435         sb.addWidget(self.balance_label)
1436
1437         from version_getter import UpdateLabel
1438         self.updatelabel = UpdateLabel(self.config, sb)
1439
1440         self.account_selector = QComboBox()
1441         self.account_selector.setSizeAdjustPolicy(QComboBox.AdjustToContents)
1442         self.connect(self.account_selector,SIGNAL("activated(QString)"),self.change_account)
1443         sb.addPermanentWidget(self.account_selector)
1444
1445         if (int(qtVersion[0]) >= 4 and int(qtVersion[2]) >= 7):
1446             sb.addPermanentWidget( StatusBarButton( QIcon(":icons/switchgui.png"), _("Switch to Lite Mode"), self.go_lite ) )
1447
1448         self.lock_icon = QIcon()
1449         self.password_button = StatusBarButton( self.lock_icon, _("Password"), self.change_password_dialog )
1450         sb.addPermanentWidget( self.password_button )
1451
1452         sb.addPermanentWidget( StatusBarButton( QIcon(":icons/preferences.png"), _("Preferences"), self.settings_dialog ) )
1453         self.seed_button = StatusBarButton( QIcon(":icons/seed.png"), _("Seed"), self.show_seed_dialog )
1454         sb.addPermanentWidget( self.seed_button )
1455         self.status_button = StatusBarButton( QIcon(":icons/status_disconnected.png"), _("Network"), self.run_network_dialog )
1456         sb.addPermanentWidget( self.status_button )
1457
1458         run_hook('create_status_bar', (sb,))
1459
1460         self.setStatusBar(sb)
1461
1462
1463     def update_lock_icon(self):
1464         icon = QIcon(":icons/lock.png") if self.wallet.use_encryption else QIcon(":icons/unlock.png")
1465         self.password_button.setIcon( icon )
1466
1467
1468     def update_buttons_on_seed(self):
1469         if self.wallet.has_seed():
1470            self.seed_button.show()
1471         else:
1472            self.seed_button.hide()
1473
1474         if not self.wallet.is_watching_only():
1475            self.password_button.show()
1476            self.send_button.setText(_("Send"))
1477         else:
1478            self.password_button.hide()
1479            self.send_button.setText(_("Create unsigned transaction"))
1480
1481
1482     def change_password_dialog(self):
1483         from password_dialog import PasswordDialog
1484         d = PasswordDialog(self.wallet, self)
1485         d.run()
1486         self.update_lock_icon()
1487
1488
1489     def new_contact_dialog(self):
1490
1491         d = QDialog(self)
1492         d.setWindowTitle(_("New Contact"))
1493         vbox = QVBoxLayout(d)
1494         vbox.addWidget(QLabel(_('New Contact')+':'))
1495
1496         grid = QGridLayout()
1497         line1 = QLineEdit()
1498         line2 = QLineEdit()
1499         grid.addWidget(QLabel(_("Address")), 1, 0)
1500         grid.addWidget(line1, 1, 1)
1501         grid.addWidget(QLabel(_("Name")), 2, 0)
1502         grid.addWidget(line2, 2, 1)
1503
1504         vbox.addLayout(grid)
1505         vbox.addLayout(ok_cancel_buttons(d))
1506
1507         if not d.exec_():
1508             return
1509
1510         address = str(line1.text())
1511         label = unicode(line2.text())
1512
1513         if not is_valid(address):
1514             QMessageBox.warning(self, _('Error'), _('Invalid Address'), _('OK'))
1515             return
1516
1517         self.wallet.add_contact(address)
1518         if label:
1519             self.wallet.set_label(address, label)
1520
1521         self.update_contacts_tab()
1522         self.update_history_tab()
1523         self.update_completions()
1524         self.tabs.setCurrentIndex(3)
1525
1526
1527     @protected
1528     def new_account_dialog(self, password):
1529
1530         dialog = QDialog(self)
1531         dialog.setModal(1)
1532         dialog.setWindowTitle(_("New Account"))
1533
1534         vbox = QVBoxLayout()
1535         vbox.addWidget(QLabel(_('Account name')+':'))
1536         e = QLineEdit()
1537         vbox.addWidget(e)
1538         msg = _("Note: Newly created accounts are 'pending' until they receive bitcoins.") + " " \
1539             + _("You will need to wait for 2 confirmations until the correct balance is displayed and more addresses are created for that account.")
1540         l = QLabel(msg)
1541         l.setWordWrap(True)
1542         vbox.addWidget(l)
1543
1544         vbox.addLayout(ok_cancel_buttons(dialog))
1545         dialog.setLayout(vbox)
1546         r = dialog.exec_()
1547         if not r: return
1548
1549         name = str(e.text())
1550         if not name: return
1551
1552         self.wallet.create_pending_account(name, password)
1553         self.update_receive_tab()
1554         self.tabs.setCurrentIndex(2)
1555
1556
1557
1558
1559     def show_master_public_keys(self):
1560
1561         dialog = QDialog(self)
1562         dialog.setModal(1)
1563         dialog.setWindowTitle(_("Master Public Keys"))
1564
1565         main_layout = QGridLayout()
1566         mpk_dict = self.wallet.get_master_public_keys()
1567         i = 0
1568         for key, value in mpk_dict.items():
1569             main_layout.addWidget(QLabel(key), i, 0)
1570             mpk_text = QTextEdit()
1571             mpk_text.setReadOnly(True)
1572             mpk_text.setMaximumHeight(170)
1573             mpk_text.setText(value)
1574             main_layout.addWidget(mpk_text, i + 1, 0)
1575             i += 2
1576
1577         vbox = QVBoxLayout()
1578         vbox.addLayout(main_layout)
1579         vbox.addLayout(close_button(dialog))
1580
1581         dialog.setLayout(vbox)
1582         dialog.exec_()
1583
1584
1585     @protected
1586     def show_seed_dialog(self, password):
1587         if not self.wallet.has_seed():
1588             QMessageBox.information(self, _('Message'), _('This wallet has no seed'), _('OK'))
1589             return
1590
1591         try:
1592             mnemonic = self.wallet.get_mnemonic(password)
1593         except Exception:
1594             QMessageBox.warning(self, _('Error'), _('Incorrect Password'), _('OK'))
1595             return
1596         from seed_dialog import SeedDialog
1597         d = SeedDialog(self, mnemonic, self.wallet.has_imported_keys())
1598         d.exec_()
1599
1600
1601
1602     def show_qrcode(self, data, title = _("QR code")):
1603         if not data: return
1604         d = QDialog(self)
1605         d.setModal(1)
1606         d.setWindowTitle(title)
1607         d.setMinimumSize(270, 300)
1608         vbox = QVBoxLayout()
1609         qrw = QRCodeWidget(data)
1610         vbox.addWidget(qrw, 1)
1611         vbox.addWidget(QLabel(data), 0, Qt.AlignHCenter)
1612         hbox = QHBoxLayout()
1613         hbox.addStretch(1)
1614
1615         filename = os.path.join(self.config.path, "qrcode.bmp")
1616
1617         def print_qr():
1618             bmp.save_qrcode(qrw.qr, filename)
1619             QMessageBox.information(None, _('Message'), _("QR code saved to file") + " " + filename, _('OK'))
1620
1621         def copy_to_clipboard():
1622             bmp.save_qrcode(qrw.qr, filename)
1623             self.app.clipboard().setImage(QImage(filename))
1624             QMessageBox.information(None, _('Message'), _("QR code saved to clipboard"), _('OK'))
1625
1626         b = QPushButton(_("Copy"))
1627         hbox.addWidget(b)
1628         b.clicked.connect(copy_to_clipboard)
1629
1630         b = QPushButton(_("Save"))
1631         hbox.addWidget(b)
1632         b.clicked.connect(print_qr)
1633
1634         b = QPushButton(_("Close"))
1635         hbox.addWidget(b)
1636         b.clicked.connect(d.accept)
1637         b.setDefault(True)
1638
1639         vbox.addLayout(hbox)
1640         d.setLayout(vbox)
1641         d.exec_()
1642
1643
1644     def do_protect(self, func, args):
1645         if self.wallet.use_encryption:
1646             password = self.password_dialog()
1647             if not password:
1648                 return
1649         else:
1650             password = None
1651
1652         if args != (False,):
1653             args = (self,) + args + (password,)
1654         else:
1655             args = (self,password)
1656         apply( func, args)
1657
1658
1659     def show_public_keys(self, address):
1660         if not address: return
1661         try:
1662             pubkey_list = self.wallet.get_public_keys(address)
1663         except Exception as e:
1664             traceback.print_exc(file=sys.stdout)
1665             self.show_message(str(e))
1666             return
1667
1668         d = QDialog(self)
1669         d.setMinimumSize(600, 200)
1670         d.setModal(1)
1671         vbox = QVBoxLayout()
1672         vbox.addWidget( QLabel(_("Address") + ': ' + address))
1673         vbox.addWidget( QLabel(_("Public key") + ':'))
1674         keys = QTextEdit()
1675         keys.setReadOnly(True)
1676         keys.setText('\n'.join(pubkey_list))
1677         vbox.addWidget(keys)
1678         #vbox.addWidget( QRCodeWidget('\n'.join(pk_list)) )
1679         vbox.addLayout(close_button(d))
1680         d.setLayout(vbox)
1681         d.exec_()
1682
1683     @protected
1684     def show_private_key(self, address, password):
1685         if not address: return
1686         try:
1687             pk_list = self.wallet.get_private_key(address, password)
1688         except Exception as e:
1689             traceback.print_exc(file=sys.stdout)
1690             self.show_message(str(e))
1691             return
1692
1693         d = QDialog(self)
1694         d.setMinimumSize(600, 200)
1695         d.setModal(1)
1696         vbox = QVBoxLayout()
1697         vbox.addWidget( QLabel(_("Address") + ': ' + address))
1698         vbox.addWidget( QLabel(_("Private key") + ':'))
1699         keys = QTextEdit()
1700         keys.setReadOnly(True)
1701         keys.setText('\n'.join(pk_list))
1702         vbox.addWidget(keys)
1703         vbox.addWidget( QRCodeWidget('\n'.join(pk_list)) )
1704         vbox.addLayout(close_button(d))
1705         d.setLayout(vbox)
1706         d.exec_()
1707
1708
1709     @protected
1710     def do_sign(self, address, message, signature, password):
1711         message = unicode(message.toPlainText())
1712         message = message.encode('utf-8')
1713         try:
1714             sig = self.wallet.sign_message(str(address.text()), message, password)
1715             signature.setText(sig)
1716         except Exception as e:
1717             self.show_message(str(e))
1718
1719     def do_verify(self, address, message, signature):
1720         message = unicode(message.toPlainText())
1721         message = message.encode('utf-8')
1722         if bitcoin.verify_message(address.text(), str(signature.toPlainText()), message):
1723             self.show_message(_("Signature verified"))
1724         else:
1725             self.show_message(_("Error: wrong signature"))
1726
1727
1728     def sign_verify_message(self, address=''):
1729         d = QDialog(self)
1730         d.setModal(1)
1731         d.setWindowTitle(_('Sign/verify Message'))
1732         d.setMinimumSize(410, 290)
1733
1734         layout = QGridLayout(d)
1735
1736         message_e = QTextEdit()
1737         layout.addWidget(QLabel(_('Message')), 1, 0)
1738         layout.addWidget(message_e, 1, 1)
1739         layout.setRowStretch(2,3)
1740
1741         address_e = QLineEdit()
1742         address_e.setText(address)
1743         layout.addWidget(QLabel(_('Address')), 2, 0)
1744         layout.addWidget(address_e, 2, 1)
1745
1746         signature_e = QTextEdit()
1747         layout.addWidget(QLabel(_('Signature')), 3, 0)
1748         layout.addWidget(signature_e, 3, 1)
1749         layout.setRowStretch(3,1)
1750
1751         hbox = QHBoxLayout()
1752
1753         b = QPushButton(_("Sign"))
1754         b.clicked.connect(lambda: self.do_sign(address_e, message_e, signature_e))
1755         hbox.addWidget(b)
1756
1757         b = QPushButton(_("Verify"))
1758         b.clicked.connect(lambda: self.do_verify(address_e, message_e, signature_e))
1759         hbox.addWidget(b)
1760
1761         b = QPushButton(_("Close"))
1762         b.clicked.connect(d.accept)
1763         hbox.addWidget(b)
1764         layout.addLayout(hbox, 4, 1)
1765         d.exec_()
1766
1767
1768     @protected
1769     def do_decrypt(self, message_e, pubkey_e, encrypted_e, password):
1770         try:
1771             decrypted = self.wallet.decrypt_message(str(pubkey_e.text()), str(encrypted_e.toPlainText()), password)
1772             message_e.setText(decrypted)
1773         except Exception as e:
1774             self.show_message(str(e))
1775
1776
1777     def do_encrypt(self, message_e, pubkey_e, encrypted_e):
1778         message = unicode(message_e.toPlainText())
1779         message = message.encode('utf-8')
1780         try:
1781             encrypted = bitcoin.encrypt_message(message, str(pubkey_e.text()))
1782             encrypted_e.setText(encrypted)
1783         except Exception as e:
1784             self.show_message(str(e))
1785
1786
1787
1788     def encrypt_message(self, address = ''):
1789         d = QDialog(self)
1790         d.setModal(1)
1791         d.setWindowTitle(_('Encrypt/decrypt Message'))
1792         d.setMinimumSize(610, 490)
1793
1794         layout = QGridLayout(d)
1795
1796         message_e = QTextEdit()
1797         layout.addWidget(QLabel(_('Message')), 1, 0)
1798         layout.addWidget(message_e, 1, 1)
1799         layout.setRowStretch(2,3)
1800
1801         pubkey_e = QLineEdit()
1802         if address:
1803             pubkey = self.wallet.getpubkeys(address)[0]
1804             pubkey_e.setText(pubkey)
1805         layout.addWidget(QLabel(_('Public key')), 2, 0)
1806         layout.addWidget(pubkey_e, 2, 1)
1807
1808         encrypted_e = QTextEdit()
1809         layout.addWidget(QLabel(_('Encrypted')), 3, 0)
1810         layout.addWidget(encrypted_e, 3, 1)
1811         layout.setRowStretch(3,1)
1812
1813         hbox = QHBoxLayout()
1814         b = QPushButton(_("Encrypt"))
1815         b.clicked.connect(lambda: self.do_encrypt(message_e, pubkey_e, encrypted_e))
1816         hbox.addWidget(b)
1817
1818         b = QPushButton(_("Decrypt"))
1819         b.clicked.connect(lambda: self.do_decrypt(message_e, pubkey_e, encrypted_e))
1820         hbox.addWidget(b)
1821
1822         b = QPushButton(_("Close"))
1823         b.clicked.connect(d.accept)
1824         hbox.addWidget(b)
1825
1826         layout.addLayout(hbox, 4, 1)
1827         d.exec_()
1828
1829
1830     def question(self, msg):
1831         return QMessageBox.question(self, _('Message'), msg, QMessageBox.Yes | QMessageBox.No, QMessageBox.No) == QMessageBox.Yes
1832
1833     def show_message(self, msg):
1834         QMessageBox.information(self, _('Message'), msg, _('OK'))
1835
1836     def password_dialog(self, msg=None):
1837         d = QDialog(self)
1838         d.setModal(1)
1839         d.setWindowTitle(_("Enter Password"))
1840
1841         pw = QLineEdit()
1842         pw.setEchoMode(2)
1843
1844         vbox = QVBoxLayout()
1845         if not msg:
1846             msg = _('Please enter your password')
1847         vbox.addWidget(QLabel(msg))
1848
1849         grid = QGridLayout()
1850         grid.setSpacing(8)
1851         grid.addWidget(QLabel(_('Password')), 1, 0)
1852         grid.addWidget(pw, 1, 1)
1853         vbox.addLayout(grid)
1854
1855         vbox.addLayout(ok_cancel_buttons(d))
1856         d.setLayout(vbox)
1857
1858         run_hook('password_dialog', pw, grid, 1)
1859         if not d.exec_(): return
1860         return unicode(pw.text())
1861
1862
1863
1864
1865
1866
1867
1868
1869     def tx_from_text(self, txt):
1870         "json or raw hexadecimal"
1871         try:
1872             txt.decode('hex')
1873             tx = Transaction(txt)
1874             return tx
1875         except Exception:
1876             pass
1877
1878         try:
1879             tx_dict = json.loads(str(txt))
1880             assert "hex" in tx_dict.keys()
1881             tx = Transaction(tx_dict["hex"])
1882             if tx_dict.has_key("input_info"):
1883                 input_info = json.loads(tx_dict['input_info'])
1884                 tx.add_input_info(input_info)
1885             return tx
1886         except Exception:
1887             traceback.print_exc(file=sys.stdout)
1888             pass
1889
1890         QMessageBox.critical(None, _("Unable to parse transaction"), _("Electrum was unable to parse your transaction"))
1891
1892
1893
1894     def read_tx_from_file(self):
1895         fileName = self.getOpenFileName(_("Select your transaction file"), "*.txn")
1896         if not fileName:
1897             return
1898         try:
1899             with open(fileName, "r") as f:
1900                 file_content = f.read()
1901         except (ValueError, IOError, os.error), reason:
1902             QMessageBox.critical(None, _("Unable to read file or no transaction found"), _("Electrum was unable to open your transaction file") + "\n" + str(reason))
1903
1904         return self.tx_from_text(file_content)
1905
1906
1907     @protected
1908     def sign_raw_transaction(self, tx, input_info, password):
1909         self.wallet.signrawtransaction(tx, input_info, [], password)
1910
1911     def do_process_from_text(self):
1912         text = text_dialog(self, _('Input raw transaction'), _("Transaction:"), _("Load transaction"))
1913         if not text:
1914             return
1915         tx = self.tx_from_text(text)
1916         if tx:
1917             self.show_transaction(tx)
1918
1919     def do_process_from_file(self):
1920         tx = self.read_tx_from_file()
1921         if tx:
1922             self.show_transaction(tx)
1923
1924     def do_process_from_txid(self):
1925         from electrum import transaction
1926         txid, ok = QInputDialog.getText(self, _('Lookup transaction'), _('Transaction ID') + ':')
1927         if ok and txid:
1928             r = self.network.synchronous_get([ ('blockchain.transaction.get',[str(txid)]) ])[0]
1929             if r:
1930                 tx = transaction.Transaction(r)
1931                 if tx:
1932                     self.show_transaction(tx)
1933                 else:
1934                     self.show_message("unknown transaction")
1935
1936     def do_process_from_csvReader(self, csvReader):
1937         outputs = []
1938         errors = []
1939         errtext = ""
1940         try:
1941             for position, row in enumerate(csvReader):
1942                 address = row[0]
1943                 if not is_valid(address):
1944                     errors.append((position, address))
1945                     continue
1946                 amount = Decimal(row[1])
1947                 amount = int(100000000*amount)
1948                 outputs.append((address, amount))
1949         except (ValueError, IOError, os.error), reason:
1950             QMessageBox.critical(None, _("Unable to read file or no transaction found"), _("Electrum was unable to open your transaction file") + "\n" + str(reason))
1951             return
1952         if errors != []:
1953             for x in errors:
1954                 errtext += "CSV Row " + str(x[0]+1) + ": " + x[1] + "\n"
1955             QMessageBox.critical(None, _("Invalid Addresses"), _("ABORTING! Invalid Addresses found:") + "\n\n" + errtext)
1956             return
1957
1958         try:
1959             tx = self.wallet.make_unsigned_transaction(outputs, None, None)
1960         except Exception as e:
1961             self.show_message(str(e))
1962             return
1963
1964         self.show_transaction(tx)
1965
1966     def do_process_from_csv_file(self):
1967         fileName = self.getOpenFileName(_("Select your transaction CSV"), "*.csv")
1968         if not fileName:
1969             return
1970         try:
1971             with open(fileName, "r") as f:
1972                 csvReader = csv.reader(f)
1973                 self.do_process_from_csvReader(csvReader)
1974         except (ValueError, IOError, os.error), reason:
1975             QMessageBox.critical(None, _("Unable to read file or no transaction found"), _("Electrum was unable to open your transaction file") + "\n" + str(reason))
1976             return
1977
1978     def do_process_from_csv_text(self):
1979         text = text_dialog(self, _('Input CSV'), _("Please enter a list of outputs.") + '\n' \
1980                                + _("Format: address, amount. One output per line"), _("Load CSV"))
1981         if not text:
1982             return
1983         f = StringIO.StringIO(text)
1984         csvReader = csv.reader(f)
1985         self.do_process_from_csvReader(csvReader)
1986
1987
1988
1989     @protected
1990     def export_privkeys_dialog(self, password):
1991         if self.wallet.is_watching_only():
1992             self.show_message(_("This is a watching-only wallet"))
1993             return
1994
1995         d = QDialog(self)
1996         d.setWindowTitle(_('Private keys'))
1997         d.setMinimumSize(850, 300)
1998         vbox = QVBoxLayout(d)
1999
2000         msg = "%s\n%s\n%s" % (_("WARNING: ALL your private keys are secret."),
2001                               _("Exposing a single private key can compromise your entire wallet!"),
2002                               _("In particular, DO NOT use 'redeem private key' services proposed by third parties."))
2003         vbox.addWidget(QLabel(msg))
2004
2005         e = QTextEdit()
2006         e.setReadOnly(True)
2007         vbox.addWidget(e)
2008
2009         defaultname = 'electrum-private-keys.csv'
2010         select_msg = _('Select file to export your private keys to')
2011         hbox, filename_e, csv_button = filename_field(self, self.config, defaultname, select_msg)
2012         vbox.addLayout(hbox)
2013
2014         h, b = ok_cancel_buttons2(d, _('Export'))
2015         b.setEnabled(False)
2016         vbox.addLayout(h)
2017
2018         private_keys = {}
2019         addresses = self.wallet.addresses(True)
2020         done = False
2021         def privkeys_thread():
2022             for addr in addresses:
2023                 time.sleep(0.1)
2024                 if done:
2025                     break
2026                 private_keys[addr] = "\n".join(self.wallet.get_private_key(addr, password))
2027                 d.emit(SIGNAL('computing_privkeys'))
2028             d.emit(SIGNAL('show_privkeys'))
2029
2030         def show_privkeys():
2031             s = "\n".join( map( lambda x: x[0] + "\t"+ x[1], private_keys.items()))
2032             e.setText(s)
2033             b.setEnabled(True)
2034
2035         d.connect(d, QtCore.SIGNAL('computing_privkeys'), lambda: e.setText("Please wait... %d/%d"%(len(private_keys),len(addresses))))
2036         d.connect(d, QtCore.SIGNAL('show_privkeys'), show_privkeys)
2037         threading.Thread(target=privkeys_thread).start()
2038
2039         if not d.exec_():
2040             done = True
2041             return
2042
2043         filename = filename_e.text()
2044         if not filename:
2045             return
2046
2047         try:
2048             self.do_export_privkeys(filename, private_keys, csv_button.isChecked())
2049         except (IOError, os.error), reason:
2050             export_error_label = _("Electrum was unable to produce a private key-export.")
2051             QMessageBox.critical(None, _("Unable to create csv"), export_error_label + "\n" + str(reason))
2052
2053         except Exception as e:
2054             self.show_message(str(e))
2055             return
2056
2057         self.show_message(_("Private keys exported."))
2058
2059
2060     def do_export_privkeys(self, fileName, pklist, is_csv):
2061         with open(fileName, "w+") as f:
2062             if is_csv:
2063                 transaction = csv.writer(f)
2064                 transaction.writerow(["address", "private_key"])
2065                 for addr, pk in pklist.items():
2066                     transaction.writerow(["%34s"%addr,pk])
2067             else:
2068                 import json
2069                 f.write(json.dumps(pklist, indent = 4))
2070
2071
2072     def do_import_labels(self):
2073         labelsFile = self.getOpenFileName(_("Open labels file"), "*.dat")
2074         if not labelsFile: return
2075         try:
2076             f = open(labelsFile, 'r')
2077             data = f.read()
2078             f.close()
2079             for key, value in json.loads(data).items():
2080                 self.wallet.set_label(key, value)
2081             QMessageBox.information(None, _("Labels imported"), _("Your labels were imported from")+" '%s'" % str(labelsFile))
2082         except (IOError, os.error), reason:
2083             QMessageBox.critical(None, _("Unable to import labels"), _("Electrum was unable to import your labels.")+"\n" + str(reason))
2084
2085
2086     def do_export_labels(self):
2087         labels = self.wallet.labels
2088         try:
2089             fileName = self.getSaveFileName(_("Select file to save your labels"), 'electrum_labels.dat', "*.dat")
2090             if fileName:
2091                 with open(fileName, 'w+') as f:
2092                     json.dump(labels, f)
2093                 QMessageBox.information(None, _("Labels exported"), _("Your labels where exported to")+" '%s'" % str(fileName))
2094         except (IOError, os.error), reason:
2095             QMessageBox.critical(None, _("Unable to export labels"), _("Electrum was unable to export your labels.")+"\n" + str(reason))
2096
2097
2098     def export_history_dialog(self):
2099
2100         d = QDialog(self)
2101         d.setWindowTitle(_('Export History'))
2102         d.setMinimumSize(400, 200)
2103         vbox = QVBoxLayout(d)
2104
2105         defaultname = os.path.expanduser('~/electrum-history.csv')
2106         select_msg = _('Select file to export your wallet transactions to')
2107
2108         hbox, filename_e, csv_button = filename_field(self, self.config, defaultname, select_msg)
2109         vbox.addLayout(hbox)
2110
2111         vbox.addStretch(1)
2112
2113         h, b = ok_cancel_buttons2(d, _('Export'))
2114         vbox.addLayout(h)
2115         if not d.exec_():
2116             return
2117
2118         filename = filename_e.text()
2119         if not filename:
2120             return
2121
2122         try:
2123             self.do_export_history(self.wallet, filename, csv_button.isChecked())
2124         except (IOError, os.error), reason:
2125             export_error_label = _("Electrum was unable to produce a transaction export.")
2126             QMessageBox.critical(self, _("Unable to export history"), export_error_label + "\n" + str(reason))
2127             return
2128
2129         QMessageBox.information(self,_("History exported"), _("Your wallet history has been successfully exported."))
2130
2131
2132     def do_export_history(self, wallet, fileName, is_csv):
2133         history = wallet.get_tx_history()
2134         lines = []
2135         for item in history:
2136             tx_hash, confirmations, is_mine, value, fee, balance, timestamp = item
2137             if confirmations:
2138                 if timestamp is not None:
2139                     try:
2140                         time_string = datetime.datetime.fromtimestamp(timestamp).isoformat(' ')[:-3]
2141                     except [RuntimeError, TypeError, NameError] as reason:
2142                         time_string = "unknown"
2143                         pass
2144                 else:
2145                     time_string = "unknown"
2146             else:
2147                 time_string = "pending"
2148
2149             if value is not None:
2150                 value_string = format_satoshis(value, True)
2151             else:
2152                 value_string = '--'
2153
2154             if fee is not None:
2155                 fee_string = format_satoshis(fee, True)
2156             else:
2157                 fee_string = '0'
2158
2159             if tx_hash:
2160                 label, is_default_label = wallet.get_label(tx_hash)
2161                 label = label.encode('utf-8')
2162             else:
2163                 label = ""
2164
2165             balance_string = format_satoshis(balance, False)
2166             if is_csv:
2167                 lines.append([tx_hash, label, confirmations, value_string, fee_string, balance_string, time_string])
2168             else:
2169                 lines.append({'txid':tx_hash, 'date':"%16s"%time_string, 'label':label, 'value':value_string})
2170
2171         with open(fileName, "w+") as f:
2172             if is_csv:
2173                 transaction = csv.writer(f)
2174                 transaction.writerow(["transaction_hash","label", "confirmations", "value", "fee", "balance", "timestamp"])
2175                 for line in lines:
2176                     transaction.writerow(line)
2177             else:
2178                 import json
2179                 f.write(json.dumps(lines, indent = 4))
2180
2181
2182     def sweep_key_dialog(self):
2183         d = QDialog(self)
2184         d.setWindowTitle(_('Sweep private keys'))
2185         d.setMinimumSize(600, 300)
2186
2187         vbox = QVBoxLayout(d)
2188         vbox.addWidget(QLabel(_("Enter private keys")))
2189
2190         keys_e = QTextEdit()
2191         keys_e.setTabChangesFocus(True)
2192         vbox.addWidget(keys_e)
2193
2194         h, address_e = address_field(self.wallet.addresses())
2195         vbox.addLayout(h)
2196
2197         vbox.addStretch(1)
2198         hbox, button = ok_cancel_buttons2(d, _('Sweep'))
2199         vbox.addLayout(hbox)
2200         button.setEnabled(False)
2201
2202         def get_address():
2203             addr = str(address_e.text())
2204             if bitcoin.is_address(addr):
2205                 return addr
2206
2207         def get_pk():
2208             pk = str(keys_e.toPlainText()).strip()
2209             if Wallet.is_private_key(pk):
2210                 return pk.split()
2211
2212         f = lambda: button.setEnabled(get_address() is not None and get_pk() is not None)
2213         keys_e.textChanged.connect(f)
2214         address_e.textChanged.connect(f)
2215         if not d.exec_():
2216             return
2217
2218         fee = self.wallet.fee
2219         tx = Transaction.sweep(get_pk(), self.network, get_address(), fee)
2220         self.show_transaction(tx)
2221
2222
2223     @protected
2224     def do_import_privkey(self, password):
2225         if not self.wallet.has_imported_keys():
2226             r = QMessageBox.question(None, _('Warning'), '<b>'+_('Warning') +':\n</b><br/>'+ _('Imported keys are not recoverable from seed.') + ' ' \
2227                                          + _('If you ever need to restore your wallet from its seed, these keys will be lost.') + '<p>' \
2228                                          + _('Are you sure you understand what you are doing?'), 3, 4)
2229             if r == 4: return
2230
2231         text = text_dialog(self, _('Import private keys'), _("Enter private keys")+':', _("Import"))
2232         if not text: return
2233
2234         text = str(text).split()
2235         badkeys = []
2236         addrlist = []
2237         for key in text:
2238             try:
2239                 addr = self.wallet.import_key(key, password)
2240             except Exception as e:
2241                 badkeys.append(key)
2242                 continue
2243             if not addr:
2244                 badkeys.append(key)
2245             else:
2246                 addrlist.append(addr)
2247         if addrlist:
2248             QMessageBox.information(self, _('Information'), _("The following addresses were added") + ':\n' + '\n'.join(addrlist))
2249         if badkeys:
2250             QMessageBox.critical(self, _('Error'), _("The following inputs could not be imported") + ':\n'+ '\n'.join(badkeys))
2251         self.update_receive_tab()
2252         self.update_history_tab()
2253
2254
2255     def settings_dialog(self):
2256         d = QDialog(self)
2257         d.setWindowTitle(_('Electrum Settings'))
2258         d.setModal(1)
2259         vbox = QVBoxLayout()
2260         grid = QGridLayout()
2261         grid.setColumnStretch(0,1)
2262
2263         nz_label = QLabel(_('Display zeros') + ':')
2264         grid.addWidget(nz_label, 0, 0)
2265         nz_e = AmountEdit(None,True)
2266         nz_e.setText("%d"% self.num_zeros)
2267         grid.addWidget(nz_e, 0, 1)
2268         msg = _('Number of zeros displayed after the decimal point. For example, if this is set to 2, "1." will be displayed as "1.00"')
2269         grid.addWidget(HelpButton(msg), 0, 2)
2270         if not self.config.is_modifiable('num_zeros'):
2271             for w in [nz_e, nz_label]: w.setEnabled(False)
2272
2273         lang_label=QLabel(_('Language') + ':')
2274         grid.addWidget(lang_label, 1, 0)
2275         lang_combo = QComboBox()
2276         from electrum.i18n import languages
2277         lang_combo.addItems(languages.values())
2278         try:
2279             index = languages.keys().index(self.config.get("language",''))
2280         except Exception:
2281             index = 0
2282         lang_combo.setCurrentIndex(index)
2283         grid.addWidget(lang_combo, 1, 1)
2284         grid.addWidget(HelpButton(_('Select which language is used in the GUI (after restart).')+' '), 1, 2)
2285         if not self.config.is_modifiable('language'):
2286             for w in [lang_combo, lang_label]: w.setEnabled(False)
2287
2288
2289         fee_label = QLabel(_('Transaction fee') + ':')
2290         grid.addWidget(fee_label, 2, 0)
2291         fee_e = BTCAmountEdit(self.get_decimal_point)
2292         fee_e.setAmount(self.wallet.fee)
2293         grid.addWidget(fee_e, 2, 1)
2294         msg = _('Fee per kilobyte of transaction.') + '\n' \
2295             + _('Recommended value') + ': ' + self.format_amount(10000) + ' ' + self.base_unit()
2296         grid.addWidget(HelpButton(msg), 2, 2)
2297         if not self.config.is_modifiable('fee_per_kb'):
2298             for w in [fee_e, fee_label]: w.setEnabled(False)
2299
2300         units = ['BTC', 'mBTC']
2301         unit_label = QLabel(_('Base unit') + ':')
2302         grid.addWidget(unit_label, 3, 0)
2303         unit_combo = QComboBox()
2304         unit_combo.addItems(units)
2305         unit_combo.setCurrentIndex(units.index(self.base_unit()))
2306         grid.addWidget(unit_combo, 3, 1)
2307         grid.addWidget(HelpButton(_('Base unit of your wallet.')\
2308                                              + '\n1BTC=1000mBTC.\n' \
2309                                              + _(' These settings affects the fields in the Send tab')+' '), 3, 2)
2310
2311         usechange_cb = QCheckBox(_('Use change addresses'))
2312         usechange_cb.setChecked(self.wallet.use_change)
2313         grid.addWidget(usechange_cb, 4, 0)
2314         grid.addWidget(HelpButton(_('Using change addresses makes it more difficult for other people to track your transactions.')+' '), 4, 2)
2315         if not self.config.is_modifiable('use_change'): usechange_cb.setEnabled(False)
2316
2317         block_explorers = ['Blockchain.info', 'Blockr.io', 'Insight.is']
2318         block_ex_label = QLabel(_('Online Block Explorer') + ':')
2319         grid.addWidget(block_ex_label, 5, 0)
2320         block_ex_combo = QComboBox()
2321         block_ex_combo.addItems(block_explorers)
2322         block_ex_combo.setCurrentIndex(block_explorers.index(self.config.get('block_explorer', 'Blockchain.info')))
2323         grid.addWidget(block_ex_combo, 5, 1)
2324         grid.addWidget(HelpButton(_('Choose which online block explorer to use for functions that open a web browser')+' '), 5, 2)
2325
2326         show_tx = self.config.get('show_before_broadcast', False)
2327         showtx_cb = QCheckBox(_('Show before broadcast'))
2328         showtx_cb.setChecked(show_tx)
2329         grid.addWidget(showtx_cb, 6, 0)
2330         grid.addWidget(HelpButton(_('Display the details of your transactions before broadcasting it.')), 6, 2)
2331
2332         vbox.addLayout(grid)
2333         vbox.addStretch(1)
2334         vbox.addLayout(ok_cancel_buttons(d))
2335         d.setLayout(vbox)
2336
2337         # run the dialog
2338         if not d.exec_(): return
2339
2340         fee = fee_e.get_amount()
2341         if fee is None:
2342             QMessageBox.warning(self, _('Error'), _('Invalid value') +': %s'%fee, _('OK'))
2343             return
2344
2345         self.wallet.set_fee(fee)
2346
2347         nz = unicode(nz_e.text())
2348         try:
2349             nz = int( nz )
2350             if nz>8: nz=8
2351         except Exception:
2352             QMessageBox.warning(self, _('Error'), _('Invalid value')+':%s'%nz, _('OK'))
2353             return
2354
2355         if self.num_zeros != nz:
2356             self.num_zeros = nz
2357             self.config.set_key('num_zeros', nz, True)
2358             self.update_history_tab()
2359             self.update_receive_tab()
2360
2361         usechange_result = usechange_cb.isChecked()
2362         if self.wallet.use_change != usechange_result:
2363             self.wallet.use_change = usechange_result
2364             self.wallet.storage.put('use_change', self.wallet.use_change)
2365
2366         if showtx_cb.isChecked() != show_tx:
2367             self.config.set_key('show_before_broadcast', not show_tx)
2368
2369         unit_result = units[unit_combo.currentIndex()]
2370         if self.base_unit() != unit_result:
2371             self.decimal_point = 8 if unit_result == 'BTC' else 5
2372             self.config.set_key('decimal_point', self.decimal_point, True)
2373             self.update_history_tab()
2374             self.update_status()
2375
2376         need_restart = False
2377
2378         lang_request = languages.keys()[lang_combo.currentIndex()]
2379         if lang_request != self.config.get('language'):
2380             self.config.set_key("language", lang_request, True)
2381             need_restart = True
2382
2383         be_result = block_explorers[block_ex_combo.currentIndex()]
2384         self.config.set_key('block_explorer', be_result, True)
2385
2386         run_hook('close_settings_dialog')
2387
2388         if need_restart:
2389             QMessageBox.warning(self, _('Success'), _('Please restart Electrum to activate the new GUI settings'), _('OK'))
2390
2391
2392     def run_network_dialog(self):
2393         if not self.network:
2394             return
2395         NetworkDialog(self.wallet.network, self.config, self).do_exec()
2396
2397     def closeEvent(self, event):
2398         self.tray.hide()
2399         self.config.set_key("is_maximized", self.isMaximized())
2400         if not self.isMaximized():
2401             g = self.geometry()
2402             self.config.set_key("winpos-qt", [g.left(),g.top(),g.width(),g.height()])
2403         self.save_column_widths()
2404         self.config.set_key("console-history", self.console.history[-50:], True)
2405         self.wallet.storage.put('accounts_expanded', self.accounts_expanded)
2406         event.accept()
2407
2408
2409     def plugins_dialog(self):
2410         from electrum.plugins import plugins
2411
2412         d = QDialog(self)
2413         d.setWindowTitle(_('Electrum Plugins'))
2414         d.setModal(1)
2415
2416         vbox = QVBoxLayout(d)
2417
2418         # plugins
2419         scroll = QScrollArea()
2420         scroll.setEnabled(True)
2421         scroll.setWidgetResizable(True)
2422         scroll.setMinimumSize(400,250)
2423         vbox.addWidget(scroll)
2424
2425         w = QWidget()
2426         scroll.setWidget(w)
2427         w.setMinimumHeight(len(plugins)*35)
2428
2429         grid = QGridLayout()
2430         grid.setColumnStretch(0,1)
2431         w.setLayout(grid)
2432
2433         def do_toggle(cb, p, w):
2434             r = p.toggle()
2435             cb.setChecked(r)
2436             if w: w.setEnabled(r)
2437
2438         def mk_toggle(cb, p, w):
2439             return lambda: do_toggle(cb,p,w)
2440
2441         for i, p in enumerate(plugins):
2442             try:
2443                 cb = QCheckBox(p.fullname())
2444                 cb.setDisabled(not p.is_available())
2445                 cb.setChecked(p.is_enabled())
2446                 grid.addWidget(cb, i, 0)
2447                 if p.requires_settings():
2448                     w = p.settings_widget(self)
2449                     w.setEnabled( p.is_enabled() )
2450                     grid.addWidget(w, i, 1)
2451                 else:
2452                     w = None
2453                 cb.clicked.connect(mk_toggle(cb,p,w))
2454                 grid.addWidget(HelpButton(p.description()), i, 2)
2455             except Exception:
2456                 print_msg(_("Error: cannot display plugin"), p)
2457                 traceback.print_exc(file=sys.stdout)
2458         grid.setRowStretch(i+1,1)
2459
2460         vbox.addLayout(close_button(d))
2461
2462         d.exec_()
2463
2464
2465     def show_account_details(self, k):
2466         account = self.wallet.accounts[k]
2467
2468         d = QDialog(self)
2469         d.setWindowTitle(_('Account Details'))
2470         d.setModal(1)
2471
2472         vbox = QVBoxLayout(d)
2473         name = self.wallet.get_account_name(k)
2474         label = QLabel('Name: ' + name)
2475         vbox.addWidget(label)
2476
2477         vbox.addWidget(QLabel(_('Address type') + ': ' + account.get_type()))
2478
2479         vbox.addWidget(QLabel(_('Derivation') + ': ' + k))
2480
2481         vbox.addWidget(QLabel(_('Master Public Key:')))
2482
2483         text = QTextEdit()
2484         text.setReadOnly(True)
2485         text.setMaximumHeight(170)
2486         vbox.addWidget(text)
2487
2488         mpk_text = '\n'.join( account.get_master_pubkeys() )
2489         text.setText(mpk_text)
2490
2491         vbox.addLayout(close_button(d))
2492         d.exec_()