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 do_pay_invoice(self, key):
1268         from electrum.paymentrequest import PaymentRequest
1269         domain, memo, value, status, tx_hash = self.invoices[key]
1270         pr = PaymentRequest(self.config)
1271         pr.read_file(key)
1272         pr.domain = domain
1273         pr.verify()
1274         self.gui_object.payment_request = pr
1275         self.prepare_for_payment_request()
1276         self.payment_request_ok()
1277
1278     def create_invoice_menu(self, position):
1279         item = self.invoices_list.itemAt(position)
1280         if not item:
1281             return
1282         k = self.invoices_list.indexOfTopLevelItem(item)
1283         key = self.invoices.keys()[k]
1284         domain, memo, value, status, tx_hash = self.invoices[key]
1285         menu = QMenu()
1286         menu.addAction(_("Details"), lambda: self.show_invoice(key))
1287         if status == PR_UNPAID:
1288             menu.addAction(_("Pay Now"), lambda: self.do_pay_invoice(key))
1289         menu.addAction(_("Delete"), lambda: self.delete_invoice(key))
1290         menu.exec_(self.invoices_list.viewport().mapToGlobal(position))
1291
1292
1293     def update_receive_item(self, item):
1294         item.setFont(0, QFont(MONOSPACE_FONT))
1295         address = str(item.data(0,0).toString())
1296         label = self.wallet.labels.get(address,'')
1297         item.setData(1,0,label)
1298         item.setData(0,32, True) # is editable
1299
1300         run_hook('update_receive_item', address, item)
1301
1302         if not self.wallet.is_mine(address): return
1303
1304         c, u = self.wallet.get_addr_balance(address)
1305         balance = self.format_amount(c + u)
1306         item.setData(2,0,balance)
1307
1308         if address in self.wallet.frozen_addresses:
1309             item.setBackgroundColor(0, QColor('lightblue'))
1310
1311
1312     def update_receive_tab(self):
1313         l = self.receive_list
1314         # extend the syntax for consistency
1315         l.addChild = l.addTopLevelItem
1316         l.insertChild = l.insertTopLevelItem
1317
1318         l.clear()
1319         for i,width in enumerate(self.column_widths['receive']):
1320             l.setColumnWidth(i, width)
1321
1322         accounts = self.wallet.get_accounts()
1323         if self.current_account is None:
1324             account_items = sorted(accounts.items())
1325         else:
1326             account_items = [(self.current_account, accounts.get(self.current_account))]
1327
1328
1329         for k, account in account_items:
1330
1331             if len(accounts) > 1:
1332                 name = self.wallet.get_account_name(k)
1333                 c,u = self.wallet.get_account_balance(k)
1334                 account_item = QTreeWidgetItem( [ name, '', self.format_amount(c+u), ''] )
1335                 l.addTopLevelItem(account_item)
1336                 account_item.setExpanded(self.accounts_expanded.get(k, True))
1337                 account_item.setData(0, 32, k)
1338             else:
1339                 account_item = l
1340
1341             sequences = [0,1] if account.has_change() else [0]
1342             for is_change in sequences:
1343                 if len(sequences) > 1:
1344                     name = _("Receiving") if not is_change else _("Change")
1345                     seq_item = QTreeWidgetItem( [ name, '', '', '', ''] )
1346                     account_item.addChild(seq_item)
1347                     if not is_change:
1348                         seq_item.setExpanded(True)
1349                 else:
1350                     seq_item = account_item
1351
1352                 used_item = QTreeWidgetItem( [ _("Used"), '', '', '', ''] )
1353                 used_flag = False
1354
1355                 is_red = False
1356                 gap = 0
1357
1358                 for address in account.get_addresses(is_change):
1359
1360                     num, is_used = self.wallet.is_used(address)
1361                     if num == 0:
1362                         gap += 1
1363                         if gap > self.wallet.gap_limit:
1364                             is_red = True
1365                     else:
1366                         gap = 0
1367
1368                     item = QTreeWidgetItem( [ address, '', '', "%d"%num] )
1369                     self.update_receive_item(item)
1370                     if is_red:
1371                         item.setBackgroundColor(1, QColor('red'))
1372
1373                     if is_used:
1374                         if not used_flag:
1375                             seq_item.insertChild(0,used_item)
1376                             used_flag = True
1377                         used_item.addChild(item)
1378                     else:
1379                         seq_item.addChild(item)
1380
1381         # we use column 1 because column 0 may be hidden
1382         l.setCurrentItem(l.topLevelItem(0),1)
1383
1384
1385     def update_contacts_tab(self):
1386         l = self.contacts_list
1387         l.clear()
1388
1389         for address in self.wallet.addressbook:
1390             label = self.wallet.labels.get(address,'')
1391             n = self.wallet.get_num_tx(address)
1392             item = QTreeWidgetItem( [ address, label, "%d"%n] )
1393             item.setFont(0, QFont(MONOSPACE_FONT))
1394             # 32 = label can be edited (bool)
1395             item.setData(0,32, True)
1396             # 33 = payto string
1397             item.setData(0,33, address)
1398             l.addTopLevelItem(item)
1399
1400         run_hook('update_contacts_tab', l)
1401         l.setCurrentItem(l.topLevelItem(0))
1402
1403
1404
1405     def create_console_tab(self):
1406         from console import Console
1407         self.console = console = Console()
1408         return console
1409
1410
1411     def update_console(self):
1412         console = self.console
1413         console.history = self.config.get("console-history",[])
1414         console.history_index = len(console.history)
1415
1416         console.updateNamespace({'wallet' : self.wallet, 'network' : self.network, 'gui':self})
1417         console.updateNamespace({'util' : util, 'bitcoin':bitcoin})
1418
1419         c = commands.Commands(self.wallet, self.network, lambda: self.console.set_json(True))
1420         methods = {}
1421         def mkfunc(f, method):
1422             return lambda *args: apply( f, (method, args, self.password_dialog ))
1423         for m in dir(c):
1424             if m[0]=='_' or m in ['network','wallet']: continue
1425             methods[m] = mkfunc(c._run, m)
1426
1427         console.updateNamespace(methods)
1428
1429
1430     def change_account(self,s):
1431         if s == _("All accounts"):
1432             self.current_account = None
1433         else:
1434             accounts = self.wallet.get_account_names()
1435             for k, v in accounts.items():
1436                 if v == s:
1437                     self.current_account = k
1438         self.update_history_tab()
1439         self.update_status()
1440         self.update_receive_tab()
1441
1442     def create_status_bar(self):
1443
1444         sb = QStatusBar()
1445         sb.setFixedHeight(35)
1446         qtVersion = qVersion()
1447
1448         self.balance_label = QLabel("")
1449         sb.addWidget(self.balance_label)
1450
1451         from version_getter import UpdateLabel
1452         self.updatelabel = UpdateLabel(self.config, sb)
1453
1454         self.account_selector = QComboBox()
1455         self.account_selector.setSizeAdjustPolicy(QComboBox.AdjustToContents)
1456         self.connect(self.account_selector,SIGNAL("activated(QString)"),self.change_account)
1457         sb.addPermanentWidget(self.account_selector)
1458
1459         if (int(qtVersion[0]) >= 4 and int(qtVersion[2]) >= 7):
1460             sb.addPermanentWidget( StatusBarButton( QIcon(":icons/switchgui.png"), _("Switch to Lite Mode"), self.go_lite ) )
1461
1462         self.lock_icon = QIcon()
1463         self.password_button = StatusBarButton( self.lock_icon, _("Password"), self.change_password_dialog )
1464         sb.addPermanentWidget( self.password_button )
1465
1466         sb.addPermanentWidget( StatusBarButton( QIcon(":icons/preferences.png"), _("Preferences"), self.settings_dialog ) )
1467         self.seed_button = StatusBarButton( QIcon(":icons/seed.png"), _("Seed"), self.show_seed_dialog )
1468         sb.addPermanentWidget( self.seed_button )
1469         self.status_button = StatusBarButton( QIcon(":icons/status_disconnected.png"), _("Network"), self.run_network_dialog )
1470         sb.addPermanentWidget( self.status_button )
1471
1472         run_hook('create_status_bar', (sb,))
1473
1474         self.setStatusBar(sb)
1475
1476
1477     def update_lock_icon(self):
1478         icon = QIcon(":icons/lock.png") if self.wallet.use_encryption else QIcon(":icons/unlock.png")
1479         self.password_button.setIcon( icon )
1480
1481
1482     def update_buttons_on_seed(self):
1483         if self.wallet.has_seed():
1484            self.seed_button.show()
1485         else:
1486            self.seed_button.hide()
1487
1488         if not self.wallet.is_watching_only():
1489            self.password_button.show()
1490            self.send_button.setText(_("Send"))
1491         else:
1492            self.password_button.hide()
1493            self.send_button.setText(_("Create unsigned transaction"))
1494
1495
1496     def change_password_dialog(self):
1497         from password_dialog import PasswordDialog
1498         d = PasswordDialog(self.wallet, self)
1499         d.run()
1500         self.update_lock_icon()
1501
1502
1503     def new_contact_dialog(self):
1504
1505         d = QDialog(self)
1506         d.setWindowTitle(_("New Contact"))
1507         vbox = QVBoxLayout(d)
1508         vbox.addWidget(QLabel(_('New Contact')+':'))
1509
1510         grid = QGridLayout()
1511         line1 = QLineEdit()
1512         line2 = QLineEdit()
1513         grid.addWidget(QLabel(_("Address")), 1, 0)
1514         grid.addWidget(line1, 1, 1)
1515         grid.addWidget(QLabel(_("Name")), 2, 0)
1516         grid.addWidget(line2, 2, 1)
1517
1518         vbox.addLayout(grid)
1519         vbox.addLayout(ok_cancel_buttons(d))
1520
1521         if not d.exec_():
1522             return
1523
1524         address = str(line1.text())
1525         label = unicode(line2.text())
1526
1527         if not is_valid(address):
1528             QMessageBox.warning(self, _('Error'), _('Invalid Address'), _('OK'))
1529             return
1530
1531         self.wallet.add_contact(address)
1532         if label:
1533             self.wallet.set_label(address, label)
1534
1535         self.update_contacts_tab()
1536         self.update_history_tab()
1537         self.update_completions()
1538         self.tabs.setCurrentIndex(3)
1539
1540
1541     @protected
1542     def new_account_dialog(self, password):
1543
1544         dialog = QDialog(self)
1545         dialog.setModal(1)
1546         dialog.setWindowTitle(_("New Account"))
1547
1548         vbox = QVBoxLayout()
1549         vbox.addWidget(QLabel(_('Account name')+':'))
1550         e = QLineEdit()
1551         vbox.addWidget(e)
1552         msg = _("Note: Newly created accounts are 'pending' until they receive bitcoins.") + " " \
1553             + _("You will need to wait for 2 confirmations until the correct balance is displayed and more addresses are created for that account.")
1554         l = QLabel(msg)
1555         l.setWordWrap(True)
1556         vbox.addWidget(l)
1557
1558         vbox.addLayout(ok_cancel_buttons(dialog))
1559         dialog.setLayout(vbox)
1560         r = dialog.exec_()
1561         if not r: return
1562
1563         name = str(e.text())
1564         if not name: return
1565
1566         self.wallet.create_pending_account(name, password)
1567         self.update_receive_tab()
1568         self.tabs.setCurrentIndex(2)
1569
1570
1571
1572
1573     def show_master_public_keys(self):
1574
1575         dialog = QDialog(self)
1576         dialog.setModal(1)
1577         dialog.setWindowTitle(_("Master Public Keys"))
1578
1579         main_layout = QGridLayout()
1580         mpk_dict = self.wallet.get_master_public_keys()
1581         i = 0
1582         for key, value in mpk_dict.items():
1583             main_layout.addWidget(QLabel(key), i, 0)
1584             mpk_text = QTextEdit()
1585             mpk_text.setReadOnly(True)
1586             mpk_text.setMaximumHeight(170)
1587             mpk_text.setText(value)
1588             main_layout.addWidget(mpk_text, i + 1, 0)
1589             i += 2
1590
1591         vbox = QVBoxLayout()
1592         vbox.addLayout(main_layout)
1593         vbox.addLayout(close_button(dialog))
1594
1595         dialog.setLayout(vbox)
1596         dialog.exec_()
1597
1598
1599     @protected
1600     def show_seed_dialog(self, password):
1601         if not self.wallet.has_seed():
1602             QMessageBox.information(self, _('Message'), _('This wallet has no seed'), _('OK'))
1603             return
1604
1605         try:
1606             mnemonic = self.wallet.get_mnemonic(password)
1607         except Exception:
1608             QMessageBox.warning(self, _('Error'), _('Incorrect Password'), _('OK'))
1609             return
1610         from seed_dialog import SeedDialog
1611         d = SeedDialog(self, mnemonic, self.wallet.has_imported_keys())
1612         d.exec_()
1613
1614
1615
1616     def show_qrcode(self, data, title = _("QR code")):
1617         if not data: return
1618         d = QDialog(self)
1619         d.setModal(1)
1620         d.setWindowTitle(title)
1621         d.setMinimumSize(270, 300)
1622         vbox = QVBoxLayout()
1623         qrw = QRCodeWidget(data)
1624         vbox.addWidget(qrw, 1)
1625         vbox.addWidget(QLabel(data), 0, Qt.AlignHCenter)
1626         hbox = QHBoxLayout()
1627         hbox.addStretch(1)
1628
1629         filename = os.path.join(self.config.path, "qrcode.bmp")
1630
1631         def print_qr():
1632             bmp.save_qrcode(qrw.qr, filename)
1633             QMessageBox.information(None, _('Message'), _("QR code saved to file") + " " + filename, _('OK'))
1634
1635         def copy_to_clipboard():
1636             bmp.save_qrcode(qrw.qr, filename)
1637             self.app.clipboard().setImage(QImage(filename))
1638             QMessageBox.information(None, _('Message'), _("QR code saved to clipboard"), _('OK'))
1639
1640         b = QPushButton(_("Copy"))
1641         hbox.addWidget(b)
1642         b.clicked.connect(copy_to_clipboard)
1643
1644         b = QPushButton(_("Save"))
1645         hbox.addWidget(b)
1646         b.clicked.connect(print_qr)
1647
1648         b = QPushButton(_("Close"))
1649         hbox.addWidget(b)
1650         b.clicked.connect(d.accept)
1651         b.setDefault(True)
1652
1653         vbox.addLayout(hbox)
1654         d.setLayout(vbox)
1655         d.exec_()
1656
1657
1658     def do_protect(self, func, args):
1659         if self.wallet.use_encryption:
1660             password = self.password_dialog()
1661             if not password:
1662                 return
1663         else:
1664             password = None
1665
1666         if args != (False,):
1667             args = (self,) + args + (password,)
1668         else:
1669             args = (self,password)
1670         apply( func, args)
1671
1672
1673     def show_public_keys(self, address):
1674         if not address: return
1675         try:
1676             pubkey_list = self.wallet.get_public_keys(address)
1677         except Exception as e:
1678             traceback.print_exc(file=sys.stdout)
1679             self.show_message(str(e))
1680             return
1681
1682         d = QDialog(self)
1683         d.setMinimumSize(600, 200)
1684         d.setModal(1)
1685         vbox = QVBoxLayout()
1686         vbox.addWidget( QLabel(_("Address") + ': ' + address))
1687         vbox.addWidget( QLabel(_("Public key") + ':'))
1688         keys = QTextEdit()
1689         keys.setReadOnly(True)
1690         keys.setText('\n'.join(pubkey_list))
1691         vbox.addWidget(keys)
1692         #vbox.addWidget( QRCodeWidget('\n'.join(pk_list)) )
1693         vbox.addLayout(close_button(d))
1694         d.setLayout(vbox)
1695         d.exec_()
1696
1697     @protected
1698     def show_private_key(self, address, password):
1699         if not address: return
1700         try:
1701             pk_list = self.wallet.get_private_key(address, password)
1702         except Exception as e:
1703             traceback.print_exc(file=sys.stdout)
1704             self.show_message(str(e))
1705             return
1706
1707         d = QDialog(self)
1708         d.setMinimumSize(600, 200)
1709         d.setModal(1)
1710         vbox = QVBoxLayout()
1711         vbox.addWidget( QLabel(_("Address") + ': ' + address))
1712         vbox.addWidget( QLabel(_("Private key") + ':'))
1713         keys = QTextEdit()
1714         keys.setReadOnly(True)
1715         keys.setText('\n'.join(pk_list))
1716         vbox.addWidget(keys)
1717         vbox.addWidget( QRCodeWidget('\n'.join(pk_list)) )
1718         vbox.addLayout(close_button(d))
1719         d.setLayout(vbox)
1720         d.exec_()
1721
1722
1723     @protected
1724     def do_sign(self, address, message, signature, password):
1725         message = unicode(message.toPlainText())
1726         message = message.encode('utf-8')
1727         try:
1728             sig = self.wallet.sign_message(str(address.text()), message, password)
1729             signature.setText(sig)
1730         except Exception as e:
1731             self.show_message(str(e))
1732
1733     def do_verify(self, address, message, signature):
1734         message = unicode(message.toPlainText())
1735         message = message.encode('utf-8')
1736         if bitcoin.verify_message(address.text(), str(signature.toPlainText()), message):
1737             self.show_message(_("Signature verified"))
1738         else:
1739             self.show_message(_("Error: wrong signature"))
1740
1741
1742     def sign_verify_message(self, address=''):
1743         d = QDialog(self)
1744         d.setModal(1)
1745         d.setWindowTitle(_('Sign/verify Message'))
1746         d.setMinimumSize(410, 290)
1747
1748         layout = QGridLayout(d)
1749
1750         message_e = QTextEdit()
1751         layout.addWidget(QLabel(_('Message')), 1, 0)
1752         layout.addWidget(message_e, 1, 1)
1753         layout.setRowStretch(2,3)
1754
1755         address_e = QLineEdit()
1756         address_e.setText(address)
1757         layout.addWidget(QLabel(_('Address')), 2, 0)
1758         layout.addWidget(address_e, 2, 1)
1759
1760         signature_e = QTextEdit()
1761         layout.addWidget(QLabel(_('Signature')), 3, 0)
1762         layout.addWidget(signature_e, 3, 1)
1763         layout.setRowStretch(3,1)
1764
1765         hbox = QHBoxLayout()
1766
1767         b = QPushButton(_("Sign"))
1768         b.clicked.connect(lambda: self.do_sign(address_e, message_e, signature_e))
1769         hbox.addWidget(b)
1770
1771         b = QPushButton(_("Verify"))
1772         b.clicked.connect(lambda: self.do_verify(address_e, message_e, signature_e))
1773         hbox.addWidget(b)
1774
1775         b = QPushButton(_("Close"))
1776         b.clicked.connect(d.accept)
1777         hbox.addWidget(b)
1778         layout.addLayout(hbox, 4, 1)
1779         d.exec_()
1780
1781
1782     @protected
1783     def do_decrypt(self, message_e, pubkey_e, encrypted_e, password):
1784         try:
1785             decrypted = self.wallet.decrypt_message(str(pubkey_e.text()), str(encrypted_e.toPlainText()), password)
1786             message_e.setText(decrypted)
1787         except Exception as e:
1788             self.show_message(str(e))
1789
1790
1791     def do_encrypt(self, message_e, pubkey_e, encrypted_e):
1792         message = unicode(message_e.toPlainText())
1793         message = message.encode('utf-8')
1794         try:
1795             encrypted = bitcoin.encrypt_message(message, str(pubkey_e.text()))
1796             encrypted_e.setText(encrypted)
1797         except Exception as e:
1798             self.show_message(str(e))
1799
1800
1801
1802     def encrypt_message(self, address = ''):
1803         d = QDialog(self)
1804         d.setModal(1)
1805         d.setWindowTitle(_('Encrypt/decrypt Message'))
1806         d.setMinimumSize(610, 490)
1807
1808         layout = QGridLayout(d)
1809
1810         message_e = QTextEdit()
1811         layout.addWidget(QLabel(_('Message')), 1, 0)
1812         layout.addWidget(message_e, 1, 1)
1813         layout.setRowStretch(2,3)
1814
1815         pubkey_e = QLineEdit()
1816         if address:
1817             pubkey = self.wallet.getpubkeys(address)[0]
1818             pubkey_e.setText(pubkey)
1819         layout.addWidget(QLabel(_('Public key')), 2, 0)
1820         layout.addWidget(pubkey_e, 2, 1)
1821
1822         encrypted_e = QTextEdit()
1823         layout.addWidget(QLabel(_('Encrypted')), 3, 0)
1824         layout.addWidget(encrypted_e, 3, 1)
1825         layout.setRowStretch(3,1)
1826
1827         hbox = QHBoxLayout()
1828         b = QPushButton(_("Encrypt"))
1829         b.clicked.connect(lambda: self.do_encrypt(message_e, pubkey_e, encrypted_e))
1830         hbox.addWidget(b)
1831
1832         b = QPushButton(_("Decrypt"))
1833         b.clicked.connect(lambda: self.do_decrypt(message_e, pubkey_e, encrypted_e))
1834         hbox.addWidget(b)
1835
1836         b = QPushButton(_("Close"))
1837         b.clicked.connect(d.accept)
1838         hbox.addWidget(b)
1839
1840         layout.addLayout(hbox, 4, 1)
1841         d.exec_()
1842
1843
1844     def question(self, msg):
1845         return QMessageBox.question(self, _('Message'), msg, QMessageBox.Yes | QMessageBox.No, QMessageBox.No) == QMessageBox.Yes
1846
1847     def show_message(self, msg):
1848         QMessageBox.information(self, _('Message'), msg, _('OK'))
1849
1850     def password_dialog(self, msg=None):
1851         d = QDialog(self)
1852         d.setModal(1)
1853         d.setWindowTitle(_("Enter Password"))
1854
1855         pw = QLineEdit()
1856         pw.setEchoMode(2)
1857
1858         vbox = QVBoxLayout()
1859         if not msg:
1860             msg = _('Please enter your password')
1861         vbox.addWidget(QLabel(msg))
1862
1863         grid = QGridLayout()
1864         grid.setSpacing(8)
1865         grid.addWidget(QLabel(_('Password')), 1, 0)
1866         grid.addWidget(pw, 1, 1)
1867         vbox.addLayout(grid)
1868
1869         vbox.addLayout(ok_cancel_buttons(d))
1870         d.setLayout(vbox)
1871
1872         run_hook('password_dialog', pw, grid, 1)
1873         if not d.exec_(): return
1874         return unicode(pw.text())
1875
1876
1877
1878
1879
1880
1881
1882
1883     def tx_from_text(self, txt):
1884         "json or raw hexadecimal"
1885         try:
1886             txt.decode('hex')
1887             tx = Transaction(txt)
1888             return tx
1889         except Exception:
1890             pass
1891
1892         try:
1893             tx_dict = json.loads(str(txt))
1894             assert "hex" in tx_dict.keys()
1895             tx = Transaction(tx_dict["hex"])
1896             if tx_dict.has_key("input_info"):
1897                 input_info = json.loads(tx_dict['input_info'])
1898                 tx.add_input_info(input_info)
1899             return tx
1900         except Exception:
1901             traceback.print_exc(file=sys.stdout)
1902             pass
1903
1904         QMessageBox.critical(None, _("Unable to parse transaction"), _("Electrum was unable to parse your transaction"))
1905
1906
1907
1908     def read_tx_from_file(self):
1909         fileName = self.getOpenFileName(_("Select your transaction file"), "*.txn")
1910         if not fileName:
1911             return
1912         try:
1913             with open(fileName, "r") as f:
1914                 file_content = f.read()
1915         except (ValueError, IOError, os.error), reason:
1916             QMessageBox.critical(None, _("Unable to read file or no transaction found"), _("Electrum was unable to open your transaction file") + "\n" + str(reason))
1917
1918         return self.tx_from_text(file_content)
1919
1920
1921     @protected
1922     def sign_raw_transaction(self, tx, input_info, password):
1923         self.wallet.signrawtransaction(tx, input_info, [], password)
1924
1925     def do_process_from_text(self):
1926         text = text_dialog(self, _('Input raw transaction'), _("Transaction:"), _("Load transaction"))
1927         if not text:
1928             return
1929         tx = self.tx_from_text(text)
1930         if tx:
1931             self.show_transaction(tx)
1932
1933     def do_process_from_file(self):
1934         tx = self.read_tx_from_file()
1935         if tx:
1936             self.show_transaction(tx)
1937
1938     def do_process_from_txid(self):
1939         from electrum import transaction
1940         txid, ok = QInputDialog.getText(self, _('Lookup transaction'), _('Transaction ID') + ':')
1941         if ok and txid:
1942             r = self.network.synchronous_get([ ('blockchain.transaction.get',[str(txid)]) ])[0]
1943             if r:
1944                 tx = transaction.Transaction(r)
1945                 if tx:
1946                     self.show_transaction(tx)
1947                 else:
1948                     self.show_message("unknown transaction")
1949
1950     def do_process_from_csvReader(self, csvReader):
1951         outputs = []
1952         errors = []
1953         errtext = ""
1954         try:
1955             for position, row in enumerate(csvReader):
1956                 address = row[0]
1957                 if not is_valid(address):
1958                     errors.append((position, address))
1959                     continue
1960                 amount = Decimal(row[1])
1961                 amount = int(100000000*amount)
1962                 outputs.append((address, amount))
1963         except (ValueError, IOError, os.error), reason:
1964             QMessageBox.critical(None, _("Unable to read file or no transaction found"), _("Electrum was unable to open your transaction file") + "\n" + str(reason))
1965             return
1966         if errors != []:
1967             for x in errors:
1968                 errtext += "CSV Row " + str(x[0]+1) + ": " + x[1] + "\n"
1969             QMessageBox.critical(None, _("Invalid Addresses"), _("ABORTING! Invalid Addresses found:") + "\n\n" + errtext)
1970             return
1971
1972         try:
1973             tx = self.wallet.make_unsigned_transaction(outputs, None, None)
1974         except Exception as e:
1975             self.show_message(str(e))
1976             return
1977
1978         self.show_transaction(tx)
1979
1980     def do_process_from_csv_file(self):
1981         fileName = self.getOpenFileName(_("Select your transaction CSV"), "*.csv")
1982         if not fileName:
1983             return
1984         try:
1985             with open(fileName, "r") as f:
1986                 csvReader = csv.reader(f)
1987                 self.do_process_from_csvReader(csvReader)
1988         except (ValueError, IOError, os.error), reason:
1989             QMessageBox.critical(None, _("Unable to read file or no transaction found"), _("Electrum was unable to open your transaction file") + "\n" + str(reason))
1990             return
1991
1992     def do_process_from_csv_text(self):
1993         text = text_dialog(self, _('Input CSV'), _("Please enter a list of outputs.") + '\n' \
1994                                + _("Format: address, amount. One output per line"), _("Load CSV"))
1995         if not text:
1996             return
1997         f = StringIO.StringIO(text)
1998         csvReader = csv.reader(f)
1999         self.do_process_from_csvReader(csvReader)
2000
2001
2002
2003     @protected
2004     def export_privkeys_dialog(self, password):
2005         if self.wallet.is_watching_only():
2006             self.show_message(_("This is a watching-only wallet"))
2007             return
2008
2009         d = QDialog(self)
2010         d.setWindowTitle(_('Private keys'))
2011         d.setMinimumSize(850, 300)
2012         vbox = QVBoxLayout(d)
2013
2014         msg = "%s\n%s\n%s" % (_("WARNING: ALL your private keys are secret."),
2015                               _("Exposing a single private key can compromise your entire wallet!"),
2016                               _("In particular, DO NOT use 'redeem private key' services proposed by third parties."))
2017         vbox.addWidget(QLabel(msg))
2018
2019         e = QTextEdit()
2020         e.setReadOnly(True)
2021         vbox.addWidget(e)
2022
2023         defaultname = 'electrum-private-keys.csv'
2024         select_msg = _('Select file to export your private keys to')
2025         hbox, filename_e, csv_button = filename_field(self, self.config, defaultname, select_msg)
2026         vbox.addLayout(hbox)
2027
2028         h, b = ok_cancel_buttons2(d, _('Export'))
2029         b.setEnabled(False)
2030         vbox.addLayout(h)
2031
2032         private_keys = {}
2033         addresses = self.wallet.addresses(True)
2034         done = False
2035         def privkeys_thread():
2036             for addr in addresses:
2037                 time.sleep(0.1)
2038                 if done:
2039                     break
2040                 private_keys[addr] = "\n".join(self.wallet.get_private_key(addr, password))
2041                 d.emit(SIGNAL('computing_privkeys'))
2042             d.emit(SIGNAL('show_privkeys'))
2043
2044         def show_privkeys():
2045             s = "\n".join( map( lambda x: x[0] + "\t"+ x[1], private_keys.items()))
2046             e.setText(s)
2047             b.setEnabled(True)
2048
2049         d.connect(d, QtCore.SIGNAL('computing_privkeys'), lambda: e.setText("Please wait... %d/%d"%(len(private_keys),len(addresses))))
2050         d.connect(d, QtCore.SIGNAL('show_privkeys'), show_privkeys)
2051         threading.Thread(target=privkeys_thread).start()
2052
2053         if not d.exec_():
2054             done = True
2055             return
2056
2057         filename = filename_e.text()
2058         if not filename:
2059             return
2060
2061         try:
2062             self.do_export_privkeys(filename, private_keys, csv_button.isChecked())
2063         except (IOError, os.error), reason:
2064             export_error_label = _("Electrum was unable to produce a private key-export.")
2065             QMessageBox.critical(None, _("Unable to create csv"), export_error_label + "\n" + str(reason))
2066
2067         except Exception as e:
2068             self.show_message(str(e))
2069             return
2070
2071         self.show_message(_("Private keys exported."))
2072
2073
2074     def do_export_privkeys(self, fileName, pklist, is_csv):
2075         with open(fileName, "w+") as f:
2076             if is_csv:
2077                 transaction = csv.writer(f)
2078                 transaction.writerow(["address", "private_key"])
2079                 for addr, pk in pklist.items():
2080                     transaction.writerow(["%34s"%addr,pk])
2081             else:
2082                 import json
2083                 f.write(json.dumps(pklist, indent = 4))
2084
2085
2086     def do_import_labels(self):
2087         labelsFile = self.getOpenFileName(_("Open labels file"), "*.dat")
2088         if not labelsFile: return
2089         try:
2090             f = open(labelsFile, 'r')
2091             data = f.read()
2092             f.close()
2093             for key, value in json.loads(data).items():
2094                 self.wallet.set_label(key, value)
2095             QMessageBox.information(None, _("Labels imported"), _("Your labels were imported from")+" '%s'" % str(labelsFile))
2096         except (IOError, os.error), reason:
2097             QMessageBox.critical(None, _("Unable to import labels"), _("Electrum was unable to import your labels.")+"\n" + str(reason))
2098
2099
2100     def do_export_labels(self):
2101         labels = self.wallet.labels
2102         try:
2103             fileName = self.getSaveFileName(_("Select file to save your labels"), 'electrum_labels.dat', "*.dat")
2104             if fileName:
2105                 with open(fileName, 'w+') as f:
2106                     json.dump(labels, f)
2107                 QMessageBox.information(None, _("Labels exported"), _("Your labels where exported to")+" '%s'" % str(fileName))
2108         except (IOError, os.error), reason:
2109             QMessageBox.critical(None, _("Unable to export labels"), _("Electrum was unable to export your labels.")+"\n" + str(reason))
2110
2111
2112     def export_history_dialog(self):
2113
2114         d = QDialog(self)
2115         d.setWindowTitle(_('Export History'))
2116         d.setMinimumSize(400, 200)
2117         vbox = QVBoxLayout(d)
2118
2119         defaultname = os.path.expanduser('~/electrum-history.csv')
2120         select_msg = _('Select file to export your wallet transactions to')
2121
2122         hbox, filename_e, csv_button = filename_field(self, self.config, defaultname, select_msg)
2123         vbox.addLayout(hbox)
2124
2125         vbox.addStretch(1)
2126
2127         h, b = ok_cancel_buttons2(d, _('Export'))
2128         vbox.addLayout(h)
2129         if not d.exec_():
2130             return
2131
2132         filename = filename_e.text()
2133         if not filename:
2134             return
2135
2136         try:
2137             self.do_export_history(self.wallet, filename, csv_button.isChecked())
2138         except (IOError, os.error), reason:
2139             export_error_label = _("Electrum was unable to produce a transaction export.")
2140             QMessageBox.critical(self, _("Unable to export history"), export_error_label + "\n" + str(reason))
2141             return
2142
2143         QMessageBox.information(self,_("History exported"), _("Your wallet history has been successfully exported."))
2144
2145
2146     def do_export_history(self, wallet, fileName, is_csv):
2147         history = wallet.get_tx_history()
2148         lines = []
2149         for item in history:
2150             tx_hash, confirmations, is_mine, value, fee, balance, timestamp = item
2151             if confirmations:
2152                 if timestamp is not None:
2153                     try:
2154                         time_string = datetime.datetime.fromtimestamp(timestamp).isoformat(' ')[:-3]
2155                     except [RuntimeError, TypeError, NameError] as reason:
2156                         time_string = "unknown"
2157                         pass
2158                 else:
2159                     time_string = "unknown"
2160             else:
2161                 time_string = "pending"
2162
2163             if value is not None:
2164                 value_string = format_satoshis(value, True)
2165             else:
2166                 value_string = '--'
2167
2168             if fee is not None:
2169                 fee_string = format_satoshis(fee, True)
2170             else:
2171                 fee_string = '0'
2172
2173             if tx_hash:
2174                 label, is_default_label = wallet.get_label(tx_hash)
2175                 label = label.encode('utf-8')
2176             else:
2177                 label = ""
2178
2179             balance_string = format_satoshis(balance, False)
2180             if is_csv:
2181                 lines.append([tx_hash, label, confirmations, value_string, fee_string, balance_string, time_string])
2182             else:
2183                 lines.append({'txid':tx_hash, 'date':"%16s"%time_string, 'label':label, 'value':value_string})
2184
2185         with open(fileName, "w+") as f:
2186             if is_csv:
2187                 transaction = csv.writer(f)
2188                 transaction.writerow(["transaction_hash","label", "confirmations", "value", "fee", "balance", "timestamp"])
2189                 for line in lines:
2190                     transaction.writerow(line)
2191             else:
2192                 import json
2193                 f.write(json.dumps(lines, indent = 4))
2194
2195
2196     def sweep_key_dialog(self):
2197         d = QDialog(self)
2198         d.setWindowTitle(_('Sweep private keys'))
2199         d.setMinimumSize(600, 300)
2200
2201         vbox = QVBoxLayout(d)
2202         vbox.addWidget(QLabel(_("Enter private keys")))
2203
2204         keys_e = QTextEdit()
2205         keys_e.setTabChangesFocus(True)
2206         vbox.addWidget(keys_e)
2207
2208         h, address_e = address_field(self.wallet.addresses())
2209         vbox.addLayout(h)
2210
2211         vbox.addStretch(1)
2212         hbox, button = ok_cancel_buttons2(d, _('Sweep'))
2213         vbox.addLayout(hbox)
2214         button.setEnabled(False)
2215
2216         def get_address():
2217             addr = str(address_e.text())
2218             if bitcoin.is_address(addr):
2219                 return addr
2220
2221         def get_pk():
2222             pk = str(keys_e.toPlainText()).strip()
2223             if Wallet.is_private_key(pk):
2224                 return pk.split()
2225
2226         f = lambda: button.setEnabled(get_address() is not None and get_pk() is not None)
2227         keys_e.textChanged.connect(f)
2228         address_e.textChanged.connect(f)
2229         if not d.exec_():
2230             return
2231
2232         fee = self.wallet.fee
2233         tx = Transaction.sweep(get_pk(), self.network, get_address(), fee)
2234         self.show_transaction(tx)
2235
2236
2237     @protected
2238     def do_import_privkey(self, password):
2239         if not self.wallet.has_imported_keys():
2240             r = QMessageBox.question(None, _('Warning'), '<b>'+_('Warning') +':\n</b><br/>'+ _('Imported keys are not recoverable from seed.') + ' ' \
2241                                          + _('If you ever need to restore your wallet from its seed, these keys will be lost.') + '<p>' \
2242                                          + _('Are you sure you understand what you are doing?'), 3, 4)
2243             if r == 4: return
2244
2245         text = text_dialog(self, _('Import private keys'), _("Enter private keys")+':', _("Import"))
2246         if not text: return
2247
2248         text = str(text).split()
2249         badkeys = []
2250         addrlist = []
2251         for key in text:
2252             try:
2253                 addr = self.wallet.import_key(key, password)
2254             except Exception as e:
2255                 badkeys.append(key)
2256                 continue
2257             if not addr:
2258                 badkeys.append(key)
2259             else:
2260                 addrlist.append(addr)
2261         if addrlist:
2262             QMessageBox.information(self, _('Information'), _("The following addresses were added") + ':\n' + '\n'.join(addrlist))
2263         if badkeys:
2264             QMessageBox.critical(self, _('Error'), _("The following inputs could not be imported") + ':\n'+ '\n'.join(badkeys))
2265         self.update_receive_tab()
2266         self.update_history_tab()
2267
2268
2269     def settings_dialog(self):
2270         d = QDialog(self)
2271         d.setWindowTitle(_('Electrum Settings'))
2272         d.setModal(1)
2273         vbox = QVBoxLayout()
2274         grid = QGridLayout()
2275         grid.setColumnStretch(0,1)
2276
2277         nz_label = QLabel(_('Display zeros') + ':')
2278         grid.addWidget(nz_label, 0, 0)
2279         nz_e = AmountEdit(None,True)
2280         nz_e.setText("%d"% self.num_zeros)
2281         grid.addWidget(nz_e, 0, 1)
2282         msg = _('Number of zeros displayed after the decimal point. For example, if this is set to 2, "1." will be displayed as "1.00"')
2283         grid.addWidget(HelpButton(msg), 0, 2)
2284         if not self.config.is_modifiable('num_zeros'):
2285             for w in [nz_e, nz_label]: w.setEnabled(False)
2286
2287         lang_label=QLabel(_('Language') + ':')
2288         grid.addWidget(lang_label, 1, 0)
2289         lang_combo = QComboBox()
2290         from electrum.i18n import languages
2291         lang_combo.addItems(languages.values())
2292         try:
2293             index = languages.keys().index(self.config.get("language",''))
2294         except Exception:
2295             index = 0
2296         lang_combo.setCurrentIndex(index)
2297         grid.addWidget(lang_combo, 1, 1)
2298         grid.addWidget(HelpButton(_('Select which language is used in the GUI (after restart).')+' '), 1, 2)
2299         if not self.config.is_modifiable('language'):
2300             for w in [lang_combo, lang_label]: w.setEnabled(False)
2301
2302
2303         fee_label = QLabel(_('Transaction fee') + ':')
2304         grid.addWidget(fee_label, 2, 0)
2305         fee_e = BTCAmountEdit(self.get_decimal_point)
2306         fee_e.setAmount(self.wallet.fee)
2307         grid.addWidget(fee_e, 2, 1)
2308         msg = _('Fee per kilobyte of transaction.') + '\n' \
2309             + _('Recommended value') + ': ' + self.format_amount(10000) + ' ' + self.base_unit()
2310         grid.addWidget(HelpButton(msg), 2, 2)
2311         if not self.config.is_modifiable('fee_per_kb'):
2312             for w in [fee_e, fee_label]: w.setEnabled(False)
2313
2314         units = ['BTC', 'mBTC']
2315         unit_label = QLabel(_('Base unit') + ':')
2316         grid.addWidget(unit_label, 3, 0)
2317         unit_combo = QComboBox()
2318         unit_combo.addItems(units)
2319         unit_combo.setCurrentIndex(units.index(self.base_unit()))
2320         grid.addWidget(unit_combo, 3, 1)
2321         grid.addWidget(HelpButton(_('Base unit of your wallet.')\
2322                                              + '\n1BTC=1000mBTC.\n' \
2323                                              + _(' These settings affects the fields in the Send tab')+' '), 3, 2)
2324
2325         usechange_cb = QCheckBox(_('Use change addresses'))
2326         usechange_cb.setChecked(self.wallet.use_change)
2327         grid.addWidget(usechange_cb, 4, 0)
2328         grid.addWidget(HelpButton(_('Using change addresses makes it more difficult for other people to track your transactions.')+' '), 4, 2)
2329         if not self.config.is_modifiable('use_change'): usechange_cb.setEnabled(False)
2330
2331         block_explorers = ['Blockchain.info', 'Blockr.io', 'Insight.is']
2332         block_ex_label = QLabel(_('Online Block Explorer') + ':')
2333         grid.addWidget(block_ex_label, 5, 0)
2334         block_ex_combo = QComboBox()
2335         block_ex_combo.addItems(block_explorers)
2336         block_ex_combo.setCurrentIndex(block_explorers.index(self.config.get('block_explorer', 'Blockchain.info')))
2337         grid.addWidget(block_ex_combo, 5, 1)
2338         grid.addWidget(HelpButton(_('Choose which online block explorer to use for functions that open a web browser')+' '), 5, 2)
2339
2340         show_tx = self.config.get('show_before_broadcast', False)
2341         showtx_cb = QCheckBox(_('Show before broadcast'))
2342         showtx_cb.setChecked(show_tx)
2343         grid.addWidget(showtx_cb, 6, 0)
2344         grid.addWidget(HelpButton(_('Display the details of your transactions before broadcasting it.')), 6, 2)
2345
2346         vbox.addLayout(grid)
2347         vbox.addStretch(1)
2348         vbox.addLayout(ok_cancel_buttons(d))
2349         d.setLayout(vbox)
2350
2351         # run the dialog
2352         if not d.exec_(): return
2353
2354         fee = fee_e.get_amount()
2355         if fee is None:
2356             QMessageBox.warning(self, _('Error'), _('Invalid value') +': %s'%fee, _('OK'))
2357             return
2358
2359         self.wallet.set_fee(fee)
2360
2361         nz = unicode(nz_e.text())
2362         try:
2363             nz = int( nz )
2364             if nz>8: nz=8
2365         except Exception:
2366             QMessageBox.warning(self, _('Error'), _('Invalid value')+':%s'%nz, _('OK'))
2367             return
2368
2369         if self.num_zeros != nz:
2370             self.num_zeros = nz
2371             self.config.set_key('num_zeros', nz, True)
2372             self.update_history_tab()
2373             self.update_receive_tab()
2374
2375         usechange_result = usechange_cb.isChecked()
2376         if self.wallet.use_change != usechange_result:
2377             self.wallet.use_change = usechange_result
2378             self.wallet.storage.put('use_change', self.wallet.use_change)
2379
2380         if showtx_cb.isChecked() != show_tx:
2381             self.config.set_key('show_before_broadcast', not show_tx)
2382
2383         unit_result = units[unit_combo.currentIndex()]
2384         if self.base_unit() != unit_result:
2385             self.decimal_point = 8 if unit_result == 'BTC' else 5
2386             self.config.set_key('decimal_point', self.decimal_point, True)
2387             self.update_history_tab()
2388             self.update_status()
2389
2390         need_restart = False
2391
2392         lang_request = languages.keys()[lang_combo.currentIndex()]
2393         if lang_request != self.config.get('language'):
2394             self.config.set_key("language", lang_request, True)
2395             need_restart = True
2396
2397         be_result = block_explorers[block_ex_combo.currentIndex()]
2398         self.config.set_key('block_explorer', be_result, True)
2399
2400         run_hook('close_settings_dialog')
2401
2402         if need_restart:
2403             QMessageBox.warning(self, _('Success'), _('Please restart Electrum to activate the new GUI settings'), _('OK'))
2404
2405
2406     def run_network_dialog(self):
2407         if not self.network:
2408             return
2409         NetworkDialog(self.wallet.network, self.config, self).do_exec()
2410
2411     def closeEvent(self, event):
2412         self.tray.hide()
2413         self.config.set_key("is_maximized", self.isMaximized())
2414         if not self.isMaximized():
2415             g = self.geometry()
2416             self.config.set_key("winpos-qt", [g.left(),g.top(),g.width(),g.height()])
2417         self.save_column_widths()
2418         self.config.set_key("console-history", self.console.history[-50:], True)
2419         self.wallet.storage.put('accounts_expanded', self.accounts_expanded)
2420         event.accept()
2421
2422
2423     def plugins_dialog(self):
2424         from electrum.plugins import plugins
2425
2426         d = QDialog(self)
2427         d.setWindowTitle(_('Electrum Plugins'))
2428         d.setModal(1)
2429
2430         vbox = QVBoxLayout(d)
2431
2432         # plugins
2433         scroll = QScrollArea()
2434         scroll.setEnabled(True)
2435         scroll.setWidgetResizable(True)
2436         scroll.setMinimumSize(400,250)
2437         vbox.addWidget(scroll)
2438
2439         w = QWidget()
2440         scroll.setWidget(w)
2441         w.setMinimumHeight(len(plugins)*35)
2442
2443         grid = QGridLayout()
2444         grid.setColumnStretch(0,1)
2445         w.setLayout(grid)
2446
2447         def do_toggle(cb, p, w):
2448             r = p.toggle()
2449             cb.setChecked(r)
2450             if w: w.setEnabled(r)
2451
2452         def mk_toggle(cb, p, w):
2453             return lambda: do_toggle(cb,p,w)
2454
2455         for i, p in enumerate(plugins):
2456             try:
2457                 cb = QCheckBox(p.fullname())
2458                 cb.setDisabled(not p.is_available())
2459                 cb.setChecked(p.is_enabled())
2460                 grid.addWidget(cb, i, 0)
2461                 if p.requires_settings():
2462                     w = p.settings_widget(self)
2463                     w.setEnabled( p.is_enabled() )
2464                     grid.addWidget(w, i, 1)
2465                 else:
2466                     w = None
2467                 cb.clicked.connect(mk_toggle(cb,p,w))
2468                 grid.addWidget(HelpButton(p.description()), i, 2)
2469             except Exception:
2470                 print_msg(_("Error: cannot display plugin"), p)
2471                 traceback.print_exc(file=sys.stdout)
2472         grid.setRowStretch(i+1,1)
2473
2474         vbox.addLayout(close_button(d))
2475
2476         d.exec_()
2477
2478
2479     def show_account_details(self, k):
2480         account = self.wallet.accounts[k]
2481
2482         d = QDialog(self)
2483         d.setWindowTitle(_('Account Details'))
2484         d.setModal(1)
2485
2486         vbox = QVBoxLayout(d)
2487         name = self.wallet.get_account_name(k)
2488         label = QLabel('Name: ' + name)
2489         vbox.addWidget(label)
2490
2491         vbox.addWidget(QLabel(_('Address type') + ': ' + account.get_type()))
2492
2493         vbox.addWidget(QLabel(_('Derivation') + ': ' + k))
2494
2495         vbox.addWidget(QLabel(_('Master Public Key:')))
2496
2497         text = QTextEdit()
2498         text.setReadOnly(True)
2499         text.setMaximumHeight(170)
2500         vbox.addWidget(text)
2501
2502         mpk_text = '\n'.join( account.get_master_pubkeys() )
2503         text.setText(mpk_text)
2504
2505         vbox.addLayout(close_button(d))
2506         d.exec_()