gui/gtk.py

   1 #!/usr/bin/env python
   2 #
   3 # Electrum - lightweight Bitcoin client
   4 # Copyright (C) 2011 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
  20 import datetime
  21 import thread, time, ast, sys, re
  22 import socket, traceback
  23 import gi
  24 gi.require_version('Gtk', '3.0')
  25 from gi.repository import Gtk, Gdk, GObject, cairo
  26 from decimal import Decimal
  27 from electrum.util import print_error
  28 from electrum.bitcoin import is_valid
  29 from electrum import mnemonic, pyqrnative, WalletStorage, Wallet
  30
  31 Gdk.threads_init()
  32 APP_NAME = "Electrum"
  33 import platform
  34 MONOSPACE_FONT = 'Lucida Console' if platform.system() == 'Windows' else 'monospace'
  35
  36 from electrum.util import format_satoshis, parse_URI
  37 from electrum.network import DEFAULT_SERVERS
  38 from electrum.bitcoin import MIN_RELAY_TX_FEE
  39
  40 def numbify(entry, is_int = False):
  41     text = entry.get_text().strip()
  42     chars = '0123456789'
  43     if not is_int: chars +='.'
  44     s = ''.join([i for i in text if i in chars])
  45     if not is_int:
  46         if '.' in s:
  47             p = s.find('.')
  48             s = s.replace('.','')
  49             s = s[:p] + '.' + s[p:p+8]
  50         try:
  51             amount = int( Decimal(s) * 100000000 )
  52         except Exception:
  53             amount = None
  54     else:
  55         try:
  56             amount = int( s )
  57         except Exception:
  58             amount = None
  59     entry.set_text(s)
  60     return amount
  61
  62
  63
  64
  65 def show_seed_dialog(seed, parent):
  66     if not seed:
  67         show_message("No seed")
  68         return
  69
  70     dialog = Gtk.MessageDialog(
  71         parent = parent,
  72         flags = Gtk.DialogFlags.MODAL,
  73         buttons = Gtk.ButtonsType.OK,
  74         message_format = "Your wallet generation seed is:\n\n" + '"' + seed + '"'\
  75             + "\n\nPlease keep it in a safe place; if you lose it, you will not be able to restore your wallet.\n\n" )
  76     dialog.set_title("Seed")
  77     dialog.show()
  78     dialog.run()
  79     dialog.destroy()
  80
  81 def restore_create_dialog():
  82
  83     # ask if the user wants to create a new wallet, or recover from a seed.
  84     # if he wants to recover, and nothing is found, do not create wallet
  85     dialog = Gtk.Dialog("electrum", parent=None,
  86                         flags=Gtk.DialogFlags.MODAL,
  87                         buttons= ("create", 0, "restore",1, "cancel",2)  )
  88
  89     label = Gtk.Label("Wallet file not found.\nDo you want to create a new wallet,\n or to restore an existing one?"  )
  90     label.show()
  91     dialog.vbox.pack_start(label, True, True, 0)
  92     dialog.show()
  93     r = dialog.run()
  94     dialog.destroy()
  95
  96     if r==2: return False
  97     return 'restore' if r==1 else 'create'
  98
  99
 100
 101 def run_recovery_dialog():
 102     message = "Please enter your wallet seed or the corresponding mnemonic list of words, and the gap limit of your wallet."
 103     dialog = Gtk.MessageDialog(
 104         parent = None,
 105         flags = Gtk.DialogFlags.MODAL,
 106         buttons = Gtk.ButtonsType.OK_CANCEL,
 107         message_format = message)
 108
 109     vbox = dialog.vbox
 110     dialog.set_default_response(Gtk.ResponseType.OK)
 111
 112     # ask seed, server and gap in the same dialog
 113     seed_box = Gtk.HBox()
 114     seed_label = Gtk.Label(label='Seed or mnemonic:')
 115     seed_label.set_size_request(150,-1)
 116     seed_box.pack_start(seed_label, False, False, 10)
 117     seed_label.show()
 118     seed_entry = Gtk.Entry()
 119     seed_entry.show()
 120     seed_entry.set_size_request(450,-1)
 121     seed_box.pack_start(seed_entry, False, False, 10)
 122     add_help_button(seed_box, '.')
 123     seed_box.show()
 124     vbox.pack_start(seed_box, False, False, 5)
 125
 126     dialog.show()
 127     r = dialog.run()
 128     seed = seed_entry.get_text()
 129     dialog.destroy()
 130
 131     if r==Gtk.ResponseType.CANCEL:
 132         return False
 133
 134     if Wallet.is_seed(seed):
 135         return seed
 136
 137     show_message("no seed")
 138     return False
 139
 140
 141
 142 def run_settings_dialog(self):
 143
 144     message = "Here are the settings of your wallet. For more explanations, click on the question mark buttons next to each input field."
 145
 146     dialog = Gtk.MessageDialog(
 147         parent = self.window,
 148         flags = Gtk.DialogFlags.MODAL,
 149         buttons = Gtk.ButtonsType.OK_CANCEL,
 150         message_format = message)
 151
 152     image = Gtk.Image()
 153     image.set_from_stock(Gtk.STOCK_PREFERENCES, Gtk.IconSize.DIALOG)
 154     image.show()
 155     dialog.set_image(image)
 156     dialog.set_title("Settings")
 157
 158     vbox = dialog.vbox
 159     dialog.set_default_response(Gtk.ResponseType.OK)
 160
 161     fee = Gtk.HBox()
 162     fee_entry = Gtk.Entry()
 163     fee_label = Gtk.Label(label='Transaction fee:')
 164     fee_label.set_size_request(150,10)
 165     fee_label.show()
 166     fee.pack_start(fee_label,False, False, 10)
 167     fee_entry.set_text( str( Decimal(self.wallet.fee) /100000000 ) )
 168     fee_entry.connect('changed', numbify, False)
 169     fee_entry.show()
 170     fee.pack_start(fee_entry,False,False, 10)
 171     add_help_button(fee, 'Fee per kilobyte of transaction. Recommended value:0.0001')
 172     fee.show()
 173     vbox.pack_start(fee, False,False, 5)
 174
 175     nz = Gtk.HBox()
 176     nz_entry = Gtk.Entry()
 177     nz_label = Gtk.Label(label='Display zeros:')
 178     nz_label.set_size_request(150,10)
 179     nz_label.show()
 180     nz.pack_start(nz_label,False, False, 10)
 181     nz_entry.set_text( str( self.num_zeros ))
 182     nz_entry.connect('changed', numbify, True)
 183     nz_entry.show()
 184     nz.pack_start(nz_entry,False,False, 10)
 185     add_help_button(nz, "Number of zeros displayed after the decimal point.\nFor example, if this number is 2, then '5.' is displayed as '5.00'")
 186     nz.show()
 187     vbox.pack_start(nz, False,False, 5)
 188
 189     dialog.show()
 190     r = dialog.run()
 191     fee = fee_entry.get_text()
 192     nz = nz_entry.get_text()
 193
 194     dialog.destroy()
 195     if r==Gtk.ResponseType.CANCEL:
 196         return
 197
 198     try:
 199         fee = int( 100000000 * Decimal(fee) )
 200     except Exception:
 201         show_message("error")
 202         return
 203     self.wallet.set_fee(fee)
 204
 205     try:
 206         nz = int( nz )
 207         if nz>8: nz = 8
 208     except Exception:
 209         show_message("error")
 210         return
 211
 212     if self.num_zeros != nz:
 213         self.num_zeros = nz
 214         self.config.set_key('num_zeros',nz,True)
 215         self.update_history_tab()
 216
 217
 218
 219
 220 def run_network_dialog( network, parent ):
 221     image = Gtk.Image()
 222     image.set_from_stock(Gtk.STOCK_NETWORK, Gtk.IconSize.DIALOG)
 223     if parent:
 224         if network.is_connected():
 225             interface = network.interface
 226             status = "Connected to %s:%d\n%d blocks"%(interface.host, interface.port, network.blockchain.height())
 227         else:
 228             status = "Not connected"
 229     else:
 230         import random
 231         status = "Please choose a server.\nSelect cancel if you are offline."
 232
 233     if network.is_connected():
 234         server = interface.server
 235         host, port, protocol = server.split(':')
 236
 237     servers = network.get_servers()
 238
 239     dialog = Gtk.MessageDialog( parent, Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT,
 240                                     Gtk.MessageType.QUESTION, Gtk.ButtonsType.OK_CANCEL, status)
 241     dialog.set_title("Server")
 242     dialog.set_image(image)
 243     image.show()
 244
 245     vbox = dialog.vbox
 246     host_box = Gtk.HBox()
 247     host_label = Gtk.Label(label='Connect to:')
 248     host_label.set_size_request(100,-1)
 249     host_label.show()
 250     host_box.pack_start(host_label, False, False, 10)
 251     host_entry = Gtk.Entry()
 252     host_entry.set_size_request(200,-1)
 253     if network.is_connected():
 254         host_entry.set_text(server)
 255     else:
 256         host_entry.set_text("Not Connected")
 257     host_entry.show()
 258     host_box.pack_start(host_entry, False, False, 10)
 259     add_help_button(host_box, 'The name, port number and protocol of your Electrum server, separated by a colon. Example: "ecdsa.org:50002:s". Some servers allow you to connect through http (port 80) or https (port 443)')
 260     host_box.show()
 261
 262     p_box = Gtk.HBox(False, 10)
 263     p_box.show()
 264
 265     p_label = Gtk.Label(label='Protocol:')
 266     p_label.set_size_request(100,-1)
 267     p_label.show()
 268     p_box.pack_start(p_label, False, False, 10)
 269
 270     combobox = Gtk.ComboBoxText()
 271     combobox.show()
 272     combobox.append_text("TCP")
 273     combobox.append_text("SSL")
 274     combobox.append_text("HTTP")
 275     combobox.append_text("HTTPS")
 276
 277     p_box.pack_start(combobox, True, True, 0)
 278
 279     def current_line():
 280         return unicode(host_entry.get_text()).split(':')
 281
 282     def set_combobox(protocol):
 283         combobox.set_active('tshg'.index(protocol))
 284
 285     def set_protocol(protocol):
 286         host = current_line()[0]
 287         pp = servers[host]
 288         if protocol not in pp.keys():
 289             protocol = pp.keys()[0]
 290             set_combobox(protocol)
 291         port = pp[protocol]
 292         host_entry.set_text( host + ':' + port + ':' + protocol)
 293
 294     combobox.connect("changed", lambda x:set_protocol('tshg'[combobox.get_active()]))
 295     if network.is_connected():
 296         set_combobox(protocol)
 297
 298     server_list = Gtk.ListStore(str)
 299     for host in servers.keys():
 300         server_list.append([host])
 301
 302     treeview = Gtk.TreeView(model=server_list)
 303     treeview.show()
 304
 305     label = 'Active Servers' if network.irc_servers else 'Default Servers'
 306     tvcolumn = Gtk.TreeViewColumn(label)
 307     treeview.append_column(tvcolumn)
 308     cell = Gtk.CellRendererText()
 309     tvcolumn.pack_start(cell, False)
 310     tvcolumn.add_attribute(cell, 'text', 0)
 311
 312     vbox.pack_start(host_box, False,False, 5)
 313     vbox.pack_start(p_box, True, True, 0)
 314
 315     #scroll = Gtk.ScrolledWindow()
 316     #scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.ALWAYS)
 317     #scroll.add_with_viewport(treeview)
 318     #scroll.show()
 319     #vbox.pack_start(scroll, True)
 320     vbox.pack_start(treeview, True, True, 0)
 321
 322     def my_treeview_cb(treeview):
 323         path, view_column = treeview.get_cursor()
 324         host = server_list.get_value( server_list.get_iter(path), 0)
 325
 326         pp = servers[host]
 327         if 't' in pp.keys():
 328             protocol = 't'
 329         else:
 330             protocol = pp.keys()[0]
 331         port = pp[protocol]
 332         host_entry.set_text( host + ':' + port + ':' + protocol)
 333         set_combobox(protocol)
 334
 335     treeview.connect('cursor-changed', my_treeview_cb)
 336
 337     dialog.show_all()
 338     r = dialog.run()
 339     server = host_entry.get_text()
 340     dialog.destroy()
 341
 342     if r==Gtk.ResponseType.CANCEL:
 343         return False
 344
 345     try:
 346         host, port, protocol = server.split(':')
 347         proxy = network.config.get('proxy')
 348         auto_connect = network.config.get('auto_cycle')
 349         network.set_parameters(host, port, protocol, proxy, auto_connect)
 350     except Exception:
 351         show_message("error:" + server)
 352         return False
 353
 354
 355
 356
 357
 358 def show_message(message, parent=None):
 359     dialog = Gtk.MessageDialog(
 360         parent = parent,
 361         flags = Gtk.DialogFlags.MODAL,
 362         buttons = Gtk.ButtonsType.CLOSE,
 363         message_format = message )
 364     dialog.show()
 365     dialog.run()
 366     dialog.destroy()
 367
 368 def password_line(label):
 369     password = Gtk.HBox()
 370     password_label = Gtk.Label(label=label)
 371     password_label.set_size_request(120,10)
 372     password_label.show()
 373     password.pack_start(password_label,False, False, 10)
 374     password_entry = Gtk.Entry()
 375     password_entry.set_size_request(300,-1)
 376     password_entry.set_visibility(False)
 377     password_entry.show()
 378     password.pack_start(password_entry,False,False, 10)
 379     password.show()
 380     return password, password_entry
 381
 382 def password_dialog(parent):
 383     dialog = Gtk.MessageDialog( parent, Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT,
 384                                 Gtk.MessageType.QUESTION, Gtk.ButtonsType.OK_CANCEL,  "Please enter your password.")
 385     dialog.get_image().set_visible(False)
 386     current_pw, current_pw_entry = password_line('Password:')
 387     current_pw_entry.connect("activate", lambda entry, dialog, response: dialog.response(response), dialog, Gtk.ResponseType.OK)
 388     dialog.vbox.pack_start(current_pw, False, True, 0)
 389     dialog.show()
 390     result = dialog.run()
 391     pw = current_pw_entry.get_text()
 392     dialog.destroy()
 393     if result != Gtk.ResponseType.CANCEL: return pw
 394
 395
 396 def change_password_dialog(is_encrypted, parent):
 397
 398     if parent:
 399         msg = 'Your wallet is encrypted. Use this dialog to change the password. To disable wallet encryption, enter an empty new password.' if is_encrypted else 'Your wallet keys are not encrypted'
 400     else:
 401         msg = "Please choose a password to encrypt your wallet keys"
 402
 403     dialog = Gtk.MessageDialog( parent, Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT, Gtk.MessageType.QUESTION, Gtk.ButtonsType.OK_CANCEL, msg)
 404     dialog.set_title("Change password")
 405     image = Gtk.Image()
 406     image.set_from_stock(Gtk.STOCK_DIALOG_AUTHENTICATION, Gtk.IconSize.DIALOG)
 407     image.show()
 408     dialog.set_image(image)
 409
 410     if is_encrypted:
 411         current_pw, current_pw_entry = password_line('Current password:')
 412         dialog.vbox.pack_start(current_pw, False, True, 0)
 413
 414     password, password_entry = password_line('New password:')
 415     dialog.vbox.pack_start(password, False, True, 5)
 416     password2, password2_entry = password_line('Confirm password:')
 417     dialog.vbox.pack_start(password2, False, True, 5)
 418
 419     dialog.show()
 420     result = dialog.run()
 421     password = current_pw_entry.get_text() if is_encrypted else None
 422     new_password = password_entry.get_text()
 423     new_password2 = password2_entry.get_text()
 424     dialog.destroy()
 425     if result == Gtk.ResponseType.CANCEL:
 426         return
 427
 428     if new_password != new_password2:
 429         show_message("passwords do not match")
 430         return change_password_dialog(is_encrypted, parent)
 431
 432     if not new_password:
 433         new_password = None
 434
 435     return True, password, new_password
 436
 437
 438
 439 def add_help_button(hbox, message):
 440     button = Gtk.Button('?')
 441     button.connect("clicked", lambda x: show_message(message))
 442     button.show()
 443     hbox.pack_start(button,False, False, 0)
 444
 445
 446 class MyWindow(Gtk.Window): __gsignals__ = dict( mykeypress = (GObject.SignalFlags.RUN_LAST | GObject.SignalFlags.ACTION, None, (str,)) )
 447
 448 GObject.type_register(MyWindow)
 449 #FIXME: can't find docs how to create keybindings in PyGI
 450 #Gtk.binding_entry_add_signall(MyWindow, Gdk.KEY_W, Gdk.ModifierType.CONTROL_MASK, 'mykeypress', ['ctrl+W'])
 451 #Gtk.binding_entry_add_signall(MyWindow, Gdk.KEY_Q, Gdk.ModifierType.CONTROL_MASK, 'mykeypress', ['ctrl+Q'])
 452
 453
 454 class ElectrumWindow:
 455
 456     def show_message(self, msg):
 457         show_message(msg, self.window)
 458
 459     def __init__(self, wallet, config, network):
 460         self.config = config
 461         self.wallet = wallet
 462         self.network = network
 463         self.funds_error = False # True if not enough funds
 464         self.num_zeros = int(self.config.get('num_zeros',0))
 465
 466         self.window = MyWindow(Gtk.WindowType.TOPLEVEL)
 467         title = 'Electrum ' + self.wallet.electrum_version + '  -  ' + self.config.path
 468         if not self.wallet.seed: title += ' [seedless]'
 469         self.window.set_title(title)
 470         self.window.connect("destroy", Gtk.main_quit)
 471         self.window.set_border_width(0)
 472         self.window.connect('mykeypress', Gtk.main_quit)
 473         self.window.set_default_size(720, 350)
 474         self.wallet_updated = False
 475
 476         vbox = Gtk.VBox()
 477
 478         self.notebook = Gtk.Notebook()
 479         self.create_history_tab()
 480         if self.wallet.seed:
 481             self.create_send_tab()
 482         self.create_recv_tab()
 483         self.create_book_tab()
 484         self.create_about_tab()
 485         self.notebook.show()
 486         vbox.pack_start(self.notebook, True, True, 2)
 487
 488         self.status_bar = Gtk.Statusbar()
 489         vbox.pack_start(self.status_bar, False, False, 0)
 490
 491         self.status_image = Gtk.Image()
 492         self.status_image.set_from_stock(Gtk.STOCK_NO, Gtk.IconSize.MENU)
 493         self.status_image.set_alignment(True, 0.5  )
 494         self.status_image.show()
 495
 496         self.network_button = Gtk.Button()
 497         self.network_button.connect("clicked", lambda x: run_network_dialog(self.network, self.window) )
 498         self.network_button.add(self.status_image)
 499         self.network_button.set_relief(Gtk.ReliefStyle.NONE)
 500         self.network_button.show()
 501         self.status_bar.pack_end(self.network_button, False, False, 0)
 502
 503         if self.wallet.seed:
 504             def seedb(w, wallet):
 505                 if wallet.use_encryption:
 506                     password = password_dialog(self.window)
 507                     if not password: return
 508                 else: password = None
 509                 seed = wallet.get_mnemonic(password)
 510                 show_seed_dialog(seed, self.window)
 511             button = Gtk.Button('S')
 512             button.connect("clicked", seedb, self.wallet )
 513             button.set_relief(Gtk.ReliefStyle.NONE)
 514             button.show()
 515             self.status_bar.pack_end(button,False, False, 0)
 516
 517         settings_icon = Gtk.Image()
 518         settings_icon.set_from_stock(Gtk.STOCK_PREFERENCES, Gtk.IconSize.MENU)
 519         settings_icon.set_alignment(0.5, 0.5)
 520         settings_icon.set_size_request(16,16 )
 521         settings_icon.show()
 522
 523         prefs_button = Gtk.Button()
 524         prefs_button.connect("clicked", lambda x: run_settings_dialog(self) )
 525         prefs_button.add(settings_icon)
 526         prefs_button.set_tooltip_text("Settings")
 527         prefs_button.set_relief(Gtk.ReliefStyle.NONE)
 528         prefs_button.show()
 529         self.status_bar.pack_end(prefs_button,False,False, 0)
 530
 531         self.pw_icon = Gtk.Image()
 532         self.pw_icon.set_from_stock(Gtk.STOCK_DIALOG_AUTHENTICATION, Gtk.IconSize.MENU)
 533         self.pw_icon.set_alignment(0.5, 0.5)
 534         self.pw_icon.set_size_request(16,16 )
 535         self.pw_icon.show()
 536
 537         if self.wallet.seed:
 538
 539             if self.wallet.use_encryption:
 540                 self.pw_icon.set_tooltip_text('Wallet is encrypted')
 541             else:
 542                 self.pw_icon.set_tooltip_text('Wallet is unencrypted')
 543
 544             password_button = Gtk.Button()
 545             password_button.connect("clicked", self.do_update_password, self.wallet)
 546             password_button.add(self.pw_icon)
 547             password_button.set_relief(Gtk.ReliefStyle.NONE)
 548             password_button.show()
 549             self.status_bar.pack_end(password_button,False,False, 0)
 550
 551         self.window.add(vbox)
 552         self.window.show_all()
 553         #self.fee_box.hide()
 554
 555         self.context_id = self.status_bar.get_context_id("statusbar")
 556         self.update_status_bar()
 557
 558         self.network.register_callback('updated', self.update_callback)
 559
 560
 561         def update_status_bar_thread():
 562             while True:
 563                 GObject.idle_add( self.update_status_bar )
 564                 time.sleep(0.5)
 565
 566
 567         def check_recipient_thread():
 568             old_r = ''
 569             while True:
 570                 time.sleep(0.5)
 571                 if self.payto_entry.is_focus():
 572                     continue
 573                 r = self.payto_entry.get_text()
 574                 if r != old_r:
 575                     old_r = r
 576                     r = r.strip()
 577                     if re.match('^(|([\w\-\.]+)@)((\w[\w\-]+\.)+[\w\-]+)$', r):
 578                         try:
 579                             to_address = self.wallet.get_alias(r, interactive=False)
 580                         except Exception:
 581                             continue
 582                         if to_address:
 583                             s = r + ' <' + to_address + '>'
 584                             GObject.idle_add( lambda: self.payto_entry.set_text(s) )
 585
 586
 587         thread.start_new_thread(update_status_bar_thread, ())
 588         if self.wallet.seed:
 589             thread.start_new_thread(check_recipient_thread, ())
 590         self.notebook.set_current_page(0)
 591
 592     def update_callback(self):
 593         self.wallet_updated = True
 594
 595     def do_update_password(self, button, wallet):
 596         if not wallet.seed:
 597             show_message("No seed")
 598             return
 599
 600         res = change_password_dialog(wallet.use_encryption, self.window)
 601         if res:
 602             _, password, new_password = res
 603
 604             try:
 605                 wallet.get_seed(password)
 606             except Exception:
 607                 show_message("Incorrect password")
 608                 return
 609
 610             wallet.update_password(password, new_password)
 611
 612             if wallet.use_encryption:
 613                 self.pw_icon.set_tooltip_text('Wallet is encrypted')
 614             else:
 615                 self.pw_icon.set_tooltip_text('Wallet is unencrypted')
 616
 617
 618     def add_tab(self, page, name):
 619         tab_label = Gtk.Label(label=name)
 620         tab_label.show()
 621         self.notebook.append_page(page, tab_label)
 622
 623
 624     def create_send_tab(self):
 625
 626         page = vbox = Gtk.VBox()
 627         page.show()
 628
 629         payto = Gtk.HBox()
 630         payto_label = Gtk.Label(label='Pay to:')
 631         payto_label.set_size_request(100,-1)
 632         payto.pack_start(payto_label, False, False, 0)
 633         payto_entry = Gtk.Entry()
 634         payto_entry.set_size_request(450, 26)
 635         payto.pack_start(payto_entry, False, False, 0)
 636         vbox.pack_start(payto, False, False, 5)
 637
 638         message = Gtk.HBox()
 639         message_label = Gtk.Label(label='Description:')
 640         message_label.set_size_request(100,-1)
 641         message.pack_start(message_label, False, False, 0)
 642         message_entry = Gtk.Entry()
 643         message_entry.set_size_request(450, 26)
 644         message.pack_start(message_entry, False, False, 0)
 645         vbox.pack_start(message, False, False, 5)
 646
 647         amount_box = Gtk.HBox()
 648         amount_label = Gtk.Label(label='Amount:')
 649         amount_label.set_size_request(100,-1)
 650         amount_box.pack_start(amount_label, False, False, 0)
 651         amount_entry = Gtk.Entry()
 652         amount_entry.set_size_request(120, -1)
 653         amount_box.pack_start(amount_entry, False, False, 0)
 654         vbox.pack_start(amount_box, False, False, 5)
 655
 656         self.fee_box = fee_box = Gtk.HBox()
 657         fee_label = Gtk.Label(label='Fee:')
 658         fee_label.set_size_request(100,-1)
 659         fee_box.pack_start(fee_label, False, False, 0)
 660         fee_entry = Gtk.Entry()
 661         fee_entry.set_size_request(60, 26)
 662         fee_box.pack_start(fee_entry, False, False, 0)
 663         vbox.pack_start(fee_box, False, False, 5)
 664
 665         end_box = Gtk.HBox()
 666         empty_label = Gtk.Label(label='')
 667         empty_label.set_size_request(100,-1)
 668         end_box.pack_start(empty_label, False, False, 0)
 669         send_button = Gtk.Button("Send")
 670         send_button.show()
 671         end_box.pack_start(send_button, False, False, 0)
 672         clear_button = Gtk.Button("Clear")
 673         clear_button.show()
 674         end_box.pack_start(clear_button, False, False, 15)
 675         send_button.connect("clicked", self.do_send, (payto_entry, message_entry, amount_entry, fee_entry))
 676         clear_button.connect("clicked", self.do_clear, (payto_entry, message_entry, amount_entry, fee_entry))
 677
 678         vbox.pack_start(end_box, False, False, 5)
 679
 680         # display this line only if there is a signature
 681         payto_sig = Gtk.HBox()
 682         payto_sig_id = Gtk.Label(label='')
 683         payto_sig.pack_start(payto_sig_id, False, False, 0)
 684         vbox.pack_start(payto_sig, True, True, 5)
 685
 686
 687         self.user_fee = False
 688
 689         def entry_changed( entry, is_fee ):
 690             self.funds_error = False
 691             amount = numbify(amount_entry)
 692             fee = numbify(fee_entry)
 693             if not is_fee: fee = None
 694             if amount is None:
 695                 return
 696             #assume two outputs - one for change
 697             inputs, total, fee = self.wallet.choose_tx_inputs( amount, fee, 2 )
 698             if not is_fee:
 699                 fee_entry.set_text( str( Decimal( fee ) / 100000000 ) )
 700                 self.fee_box.show()
 701             if inputs:
 702                 amount_entry.modify_text(Gtk.StateType.NORMAL, Gdk.color_parse("#000000"))
 703                 fee_entry.modify_text(Gtk.StateType.NORMAL, Gdk.color_parse("#000000"))
 704                 send_button.set_sensitive(True)
 705             else:
 706                 send_button.set_sensitive(False)
 707                 amount_entry.modify_text(Gtk.StateType.NORMAL, Gdk.color_parse("#cc0000"))
 708                 fee_entry.modify_text(Gtk.StateType.NORMAL, Gdk.color_parse("#cc0000"))
 709                 self.funds_error = True
 710
 711         amount_entry.connect('changed', entry_changed, False)
 712         fee_entry.connect('changed', entry_changed, True)
 713
 714         self.payto_entry = payto_entry
 715         self.payto_fee_entry = fee_entry
 716         self.payto_sig_id = payto_sig_id
 717         self.payto_sig = payto_sig
 718         self.amount_entry = amount_entry
 719         self.message_entry = message_entry
 720         self.add_tab(page, 'Send')
 721
 722     def set_frozen(self,entry,frozen):
 723         if frozen:
 724             entry.set_editable(False)
 725             entry.set_has_frame(False)
 726             entry.modify_base(Gtk.StateType.NORMAL, Gdk.color_parse("#eeeeee"))
 727         else:
 728             entry.set_editable(True)
 729             entry.set_has_frame(True)
 730             entry.modify_base(Gtk.StateType.NORMAL, Gdk.color_parse("#ffffff"))
 731
 732     def set_url(self, url):
 733         payto, amount, label, message, payment_request = parse_URI(url)
 734         self.notebook.set_current_page(1)
 735         self.payto_entry.set_text(payto)
 736         self.message_entry.set_text(message)
 737         self.amount_entry.set_text(amount)
 738         self.payto_sig.set_visible(False)
 739
 740     def create_about_tab(self):
 741         from gi.repository import Pango
 742         page = Gtk.VBox()
 743         page.show()
 744         tv = Gtk.TextView()
 745         tv.set_editable(False)
 746         tv.set_cursor_visible(False)
 747         tv.modify_font(Pango.FontDescription(MONOSPACE_FONT))
 748         scroll = Gtk.ScrolledWindow()
 749         scroll.add(tv)
 750         page.pack_start(scroll, True, True, 0)
 751         self.info = tv.get_buffer()
 752         self.add_tab(page, 'Wall')
 753
 754     def do_clear(self, w, data):
 755         self.payto_sig.set_visible(False)
 756         self.payto_fee_entry.set_text('')
 757         for entry in [self.payto_entry,self.amount_entry,self.message_entry]:
 758             self.set_frozen(entry,False)
 759             entry.set_text('')
 760
 761     def question(self,msg):
 762         dialog = Gtk.MessageDialog( self.window, Gtk.DialogFlags.MODAL | Gtk.DialogFlags.DESTROY_WITH_PARENT, Gtk.MessageType.QUESTION, Gtk.ButtonsType.OK_CANCEL, msg)
 763         dialog.show()
 764         result = dialog.run()
 765         dialog.destroy()
 766         return result == Gtk.ResponseType.OK
 767
 768     def do_send(self, w, data):
 769         payto_entry, label_entry, amount_entry, fee_entry = data
 770         label = label_entry.get_text()
 771         r = payto_entry.get_text()
 772         r = r.strip()
 773
 774         m1 = re.match('^(|([\w\-\.]+)@)((\w[\w\-]+\.)+[\w\-]+)$', r)
 775         m2 = re.match('(|([\w\-\.]+)@)((\w[\w\-]+\.)+[\w\-]+) \<([1-9A-HJ-NP-Za-km-z]{26,})\>', r)
 776
 777         if m1:
 778             to_address = self.wallet.get_alias(r, True, self.show_message, self.question)
 779             if not to_address:
 780                 return
 781             else:
 782                 self.update_sending_tab()
 783
 784         elif m2:
 785             to_address = m2.group(5)
 786         else:
 787             to_address = r
 788
 789         if not is_valid(to_address):
 790             self.show_message( "invalid bitcoin address:\n"+to_address)
 791             return
 792
 793         try:
 794             amount = int( Decimal(amount_entry.get_text()) * 100000000 )
 795         except Exception:
 796             self.show_message( "invalid amount")
 797             return
 798         try:
 799             fee = int( Decimal(fee_entry.get_text()) * 100000000 )
 800         except Exception:
 801             self.show_message( "invalid fee")
 802             return
 803
 804         if self.wallet.use_encryption:
 805             password = password_dialog(self.window)
 806             if not password:
 807                 return
 808         else:
 809             password = None
 810
 811         try:
 812             tx = self.wallet.mktx( [(to_address, amount)], password, fee )
 813         except Exception as e:
 814             self.show_message(str(e))
 815             return
 816
 817         if tx.requires_fee(self.wallet.verifier) and fee < MIN_RELAY_TX_FEE:
 818             self.show_message( "This transaction requires a higher fee, or it will not be propagated by the network." )
 819             return
 820
 821
 822         if label:
 823             self.wallet.labels[tx.hash()] = label
 824
 825         status, msg = self.wallet.sendtx( tx )
 826         if status:
 827             self.show_message( "payment sent.\n" + msg )
 828             payto_entry.set_text("")
 829             label_entry.set_text("")
 830             amount_entry.set_text("")
 831             fee_entry.set_text("")
 832             #self.fee_box.hide()
 833             self.update_sending_tab()
 834         else:
 835             self.show_message( msg )
 836
 837
 838     def treeview_button_press(self, treeview, event):
 839         if event.type == Gdk.EventType.DOUBLE_BUTTON_PRESS:
 840             c = treeview.get_cursor()[0]
 841             if treeview == self.history_treeview:
 842                 tx_details = self.history_list.get_value( self.history_list.get_iter(c), 8)
 843                 self.show_message(tx_details)
 844             elif treeview == self.contacts_treeview:
 845                 m = self.addressbook_list.get_value( self.addressbook_list.get_iter(c), 0)
 846                 #a = self.wallet.aliases.get(m)
 847                 #if a:
 848                 #    if a[0] in self.wallet.authorities.keys():
 849                 #        s = self.wallet.authorities.get(a[0])
 850                 #    else:
 851                 #        s = "self-signed"
 852                 #    msg = 'Alias: '+ m + '\nTarget address: '+ a[1] + '\n\nSigned by: ' + s + '\nSigning address:' + a[0]
 853                 #    self.show_message(msg)
 854
 855
 856     def treeview_key_press(self, treeview, event):
 857         c = treeview.get_cursor()[0]
 858         if event.keyval == Gdk.KEY_Up:
 859             if c and c[0] == 0:
 860                 treeview.parent.grab_focus()
 861                 treeview.set_cursor((0,))
 862         elif event.keyval == Gdk.KEY_Return:
 863             if treeview == self.history_treeview:
 864                 tx_details = self.history_list.get_value( self.history_list.get_iter(c), 8)
 865                 self.show_message(tx_details)
 866             elif treeview == self.contacts_treeview:
 867                 m = self.addressbook_list.get_value( self.addressbook_list.get_iter(c), 0)
 868                 #a = self.wallet.aliases.get(m)
 869                 #if a:
 870                 #    if a[0] in self.wallet.authorities.keys():
 871                 #        s = self.wallet.authorities.get(a[0])
 872                 #    else:
 873                 #        s = "self"
 874                 #    msg = 'Alias:'+ m + '\n\nTarget: '+ a[1] + '\nSigned by: ' + s + '\nSigning address:' + a[0]
 875                 #    self.show_message(msg)
 876
 877         return False
 878
 879     def create_history_tab(self):
 880
 881         self.history_list = Gtk.ListStore(str, str, str, str, 'gboolean',  str, str, str, str)
 882         treeview = Gtk.TreeView(model=self.history_list)
 883         self.history_treeview = treeview
 884         treeview.set_tooltip_column(7)
 885         treeview.show()
 886         treeview.connect('key-press-event', self.treeview_key_press)
 887         treeview.connect('button-press-event', self.treeview_button_press)
 888
 889         tvcolumn = Gtk.TreeViewColumn('')
 890         treeview.append_column(tvcolumn)
 891         cell = Gtk.CellRendererPixbuf()
 892         tvcolumn.pack_start(cell, False)
 893         tvcolumn.set_attributes(cell, stock_id=1)
 894
 895         tvcolumn = Gtk.TreeViewColumn('Date')
 896         treeview.append_column(tvcolumn)
 897         cell = Gtk.CellRendererText()
 898         tvcolumn.pack_start(cell, False)
 899         tvcolumn.add_attribute(cell, 'text', 2)
 900
 901         tvcolumn = Gtk.TreeViewColumn('Description')
 902         treeview.append_column(tvcolumn)
 903         cell = Gtk.CellRendererText()
 904         cell.set_property('foreground', 'grey')
 905         cell.set_property('family', MONOSPACE_FONT)
 906         cell.set_property('editable', True)
 907         def edited_cb(cell, path, new_text, h_list):
 908             tx = h_list.get_value( h_list.get_iter(path), 0)
 909             self.wallet.set_label(tx,new_text)
 910             self.update_history_tab()
 911         cell.connect('edited', edited_cb, self.history_list)
 912         def editing_started(cell, entry, path, h_list):
 913             tx = h_list.get_value( h_list.get_iter(path), 0)
 914             if not self.wallet.labels.get(tx): entry.set_text('')
 915         cell.connect('editing-started', editing_started, self.history_list)
 916         tvcolumn.set_expand(True)
 917         tvcolumn.pack_start(cell, True)
 918         tvcolumn.set_attributes(cell, text=3, foreground_set = 4)
 919
 920         tvcolumn = Gtk.TreeViewColumn('Amount')
 921         treeview.append_column(tvcolumn)
 922         cell = Gtk.CellRendererText()
 923         cell.set_alignment(1, 0.5)
 924         cell.set_property('family', MONOSPACE_FONT)
 925         tvcolumn.pack_start(cell, False)
 926         tvcolumn.add_attribute(cell, 'text', 5)
 927
 928         tvcolumn = Gtk.TreeViewColumn('Balance')
 929         treeview.append_column(tvcolumn)
 930         cell = Gtk.CellRendererText()
 931         cell.set_alignment(1, 0.5)
 932         cell.set_property('family', MONOSPACE_FONT)
 933         tvcolumn.pack_start(cell, False)
 934         tvcolumn.add_attribute(cell, 'text', 6)
 935
 936         tvcolumn = Gtk.TreeViewColumn('Tooltip')
 937         treeview.append_column(tvcolumn)
 938         cell = Gtk.CellRendererText()
 939         tvcolumn.pack_start(cell, False)
 940         tvcolumn.add_attribute(cell, 'text', 7)
 941         tvcolumn.set_visible(False)
 942
 943         scroll = Gtk.ScrolledWindow()
 944         scroll.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
 945         scroll.add(treeview)
 946
 947         self.add_tab(scroll, 'History')
 948         self.update_history_tab()
 949
 950
 951     def create_recv_tab(self):
 952         self.recv_list = Gtk.ListStore(str, str, str, str, str)
 953         self.add_tab( self.make_address_list(True), 'Receive')
 954         self.update_receiving_tab()
 955
 956     def create_book_tab(self):
 957         self.addressbook_list = Gtk.ListStore(str, str, str)
 958         self.add_tab( self.make_address_list(False), 'Contacts')
 959         self.update_sending_tab()
 960
 961     def make_address_list(self, is_recv):
 962         liststore = self.recv_list if is_recv else self.addressbook_list
 963         treeview = Gtk.TreeView(model= liststore)
 964         treeview.connect('key-press-event', self.treeview_key_press)
 965         treeview.connect('button-press-event', self.treeview_button_press)
 966         treeview.show()
 967         if not is_recv:
 968             self.contacts_treeview = treeview
 969
 970         tvcolumn = Gtk.TreeViewColumn('Address')
 971         treeview.append_column(tvcolumn)
 972         cell = Gtk.CellRendererText()
 973         cell.set_property('family', MONOSPACE_FONT)
 974         tvcolumn.pack_start(cell, True)
 975         tvcolumn.add_attribute(cell, 'text', 0)
 976
 977         tvcolumn = Gtk.TreeViewColumn('Label')
 978         tvcolumn.set_expand(True)
 979         treeview.append_column(tvcolumn)
 980         cell = Gtk.CellRendererText()
 981         cell.set_property('editable', True)
 982         def edited_cb2(cell, path, new_text, liststore):
 983             address = liststore.get_value( liststore.get_iter(path), 0)
 984             self.wallet.set_label(address, new_text)
 985             self.update_receiving_tab()
 986             self.update_sending_tab()
 987             self.update_history_tab()
 988         cell.connect('edited', edited_cb2, liststore)
 989         tvcolumn.pack_start(cell, True)
 990         tvcolumn.add_attribute(cell, 'text', 1)
 991
 992         tvcolumn = Gtk.TreeViewColumn('Tx')
 993         treeview.append_column(tvcolumn)
 994         cell = Gtk.CellRendererText()
 995         tvcolumn.pack_start(cell, True)
 996         tvcolumn.add_attribute(cell, 'text', 2)
 997
 998         if is_recv:
 999             tvcolumn = Gtk.TreeViewColumn('Balance')
1000             treeview.append_column(tvcolumn)
1001             cell = Gtk.CellRendererText()
1002             tvcolumn.pack_start(cell, True)
1003             tvcolumn.add_attribute(cell, 'text', 3)
1004             tvcolumn = Gtk.TreeViewColumn('Type')
1005             treeview.append_column(tvcolumn)
1006             cell = Gtk.CellRendererText()
1007             tvcolumn.pack_start(cell, True)
1008             tvcolumn.add_attribute(cell, 'text', 4)
1009
1010         scroll = Gtk.ScrolledWindow()
1011         scroll.set_policy(Gtk.PolicyType.AUTOMATIC, Gtk.PolicyType.AUTOMATIC)
1012         scroll.add(treeview)
1013
1014         hbox = Gtk.HBox()
1015         if not is_recv:
1016             button = Gtk.Button("New")
1017             button.connect("clicked", self.newaddress_dialog)
1018             button.show()
1019             hbox.pack_start(button,False, False, 0)
1020
1021         def showqrcode(w, treeview, liststore):
1022             path, col = treeview.get_cursor()
1023             if not path: return
1024             address = liststore.get_value(liststore.get_iter(path), 0)
1025             qr = pyqrnative.QRCode(4, pyqrnative.QRErrorCorrectLevel.H)
1026             qr.addData(address)
1027             qr.make()
1028             boxsize = 7
1029             boxcount_row = qr.getModuleCount()
1030             size = (boxcount_row + 4) * boxsize
1031             def area_expose_cb(area, cr):
1032                 style = area.get_style()
1033                 Gdk.cairo_set_source_color(cr, style.white)
1034                 cr.rectangle(0, 0, size, size)
1035                 cr.fill()
1036                 Gdk.cairo_set_source_color(cr, style.black)
1037                 for r in range(boxcount_row):
1038                     for c in range(boxcount_row):
1039                         if qr.isDark(r, c):
1040                             cr.rectangle((c + 2) * boxsize, (r + 2) * boxsize, boxsize, boxsize)
1041                             cr.fill()
1042             area = Gtk.DrawingArea()
1043             area.set_size_request(size, size)
1044             area.connect("draw", area_expose_cb)
1045             area.show()
1046             dialog = Gtk.Dialog(address, parent=self.window, flags=Gtk.DialogFlags.MODAL, buttons = ("ok",1))
1047             dialog.vbox.add(area)
1048             dialog.run()
1049             dialog.destroy()
1050
1051         button = Gtk.Button("QR")
1052         button.connect("clicked", showqrcode, treeview, liststore)
1053         button.show()
1054         hbox.pack_start(button,False, False, 0)
1055
1056         button = Gtk.Button("Copy to clipboard")
1057         def copy2clipboard(w, treeview, liststore):
1058             import platform
1059             path, col =  treeview.get_cursor()
1060             if path:
1061                 address =  liststore.get_value( liststore.get_iter(path), 0)
1062                 if platform.system() == 'Windows':
1063                     from Tkinter import Tk
1064                     r = Tk()
1065                     r.withdraw()
1066                     r.clipboard_clear()
1067                     r.clipboard_append( address )
1068                     r.destroy()
1069                 else:
1070                     atom = Gdk.atom_intern('CLIPBOARD', True)
1071                     c = Gtk.Clipboard.get(atom)
1072                     c.set_text( address, len(address) )
1073         button.connect("clicked", copy2clipboard, treeview, liststore)
1074         button.show()
1075         hbox.pack_start(button,False, False, 0)
1076
1077         if is_recv:
1078             button = Gtk.Button("Freeze")
1079             def freeze_address(w, treeview, liststore, wallet):
1080                 path, col = treeview.get_cursor()
1081                 if path:
1082                     address = liststore.get_value( liststore.get_iter(path), 0)
1083                     if address in wallet.frozen_addresses:
1084                         wallet.unfreeze(address)
1085                     else:
1086                         wallet.freeze(address)
1087                     self.update_receiving_tab()
1088             button.connect("clicked", freeze_address, treeview, liststore, self.wallet)
1089             button.show()
1090             hbox.pack_start(button,False, False, 0)
1091
1092         if not is_recv:
1093             button = Gtk.Button("Pay to")
1094             def payto(w, treeview, liststore):
1095                 path, col =  treeview.get_cursor()
1096                 if path:
1097                     address =  liststore.get_value( liststore.get_iter(path), 0)
1098                     self.payto_entry.set_text( address )
1099                     self.notebook.set_current_page(1)
1100                     self.amount_entry.grab_focus()
1101
1102             button.connect("clicked", payto, treeview, liststore)
1103             button.show()
1104             hbox.pack_start(button,False, False, 0)
1105
1106         vbox = Gtk.VBox()
1107         vbox.pack_start(scroll,True, True, 0)
1108         vbox.pack_start(hbox, False, False, 0)
1109         return vbox
1110
1111     def update_status_bar(self):
1112         interface = self.network.interface
1113         if self.funds_error:
1114             text = "Not enough funds"
1115         elif interface and interface.is_connected:
1116             self.network_button.set_tooltip_text("Connected to %s:%d.\n%d blocks"%(interface.host, interface.port, self.network.blockchain.height()))
1117             if not self.wallet.up_to_date:
1118                 self.status_image.set_from_stock(Gtk.STOCK_REFRESH, Gtk.IconSize.MENU)
1119                 text = "Synchronizing..."
1120             else:
1121                 self.status_image.set_from_stock(Gtk.STOCK_YES, Gtk.IconSize.MENU)
1122                 self.network_button.set_tooltip_text("Connected to %s:%d.\n%d blocks"%(interface.host, interface.port, self.network.blockchain.height()))
1123                 c, u = self.wallet.get_balance()
1124                 text =  "Balance: %s "%( format_satoshis(c,False,self.num_zeros) )
1125                 if u: text +=  "[%s unconfirmed]"%( format_satoshis(u,True,self.num_zeros).strip() )
1126         else:
1127             self.status_image.set_from_stock(Gtk.STOCK_NO, Gtk.IconSize.MENU)
1128             self.network_button.set_tooltip_text("Not connected.")
1129             text = "Not connected"
1130
1131         self.status_bar.pop(self.context_id)
1132         self.status_bar.push(self.context_id, text)
1133
1134         if self.wallet.up_to_date and self.wallet_updated:
1135             self.update_history_tab()
1136             self.update_receiving_tab()
1137             # addressbook too...
1138             self.info.set_text( self.network.banner )
1139             self.wallet_updated = False
1140
1141     def update_receiving_tab(self):
1142         self.recv_list.clear()
1143         for address in self.wallet.addresses(True):
1144             Type = "R"
1145             c = u = 0
1146             if self.wallet.is_change(address): Type = "C"
1147             if address in self.wallet.imported_keys.keys():
1148                 Type = "I"
1149             c, u = self.wallet.get_addr_balance(address)
1150             if address in self.wallet.frozen_addresses: Type = Type + "F"
1151             label = self.wallet.labels.get(address)
1152             h = self.wallet.history.get(address,[])
1153             n = len(h)
1154             tx = "0" if n==0 else "%d"%n
1155             self.recv_list.append((address, label, tx, format_satoshis(c,False,self.num_zeros), Type ))
1156
1157     def update_sending_tab(self):
1158         # detect addresses that are not mine in history, add them here...
1159         self.addressbook_list.clear()
1160         #for alias, v in self.wallet.aliases.items():
1161         #    s, target = v
1162         #    label = self.wallet.labels.get(alias)
1163         #    self.addressbook_list.append((alias, label, '-'))
1164
1165         for address in self.wallet.addressbook:
1166             label = self.wallet.labels.get(address)
1167             n = self.wallet.get_num_tx(address)
1168             self.addressbook_list.append((address, label, "%d"%n))
1169
1170     def update_history_tab(self):
1171         cursor = self.history_treeview.get_cursor()[0]
1172         self.history_list.clear()
1173
1174         for item in self.wallet.get_tx_history():
1175             tx_hash, conf, is_mine, value, fee, balance, timestamp = item
1176             if conf > 0:
1177                 try:
1178                     time_str = datetime.datetime.fromtimestamp( timestamp).isoformat(' ')[:-3]
1179                 except Exception:
1180                     time_str = "------"
1181                 conf_icon = Gtk.STOCK_APPLY
1182             elif conf == -1:
1183                 time_str = 'unverified'
1184                 conf_icon = None
1185             else:
1186                 time_str = 'pending'
1187                 conf_icon = Gtk.STOCK_EXECUTE
1188
1189             label, is_default_label = self.wallet.get_label(tx_hash)
1190             tooltip = tx_hash + "\n%d confirmations"%conf if tx_hash else ''
1191             details = self.get_tx_details(tx_hash)
1192
1193             self.history_list.prepend( [tx_hash, conf_icon, time_str, label, is_default_label,
1194                                         format_satoshis(value,True,self.num_zeros, whitespaces=True),
1195                                         format_satoshis(balance,False,self.num_zeros, whitespaces=True), tooltip, details] )
1196         if cursor: self.history_treeview.set_cursor( cursor )
1197
1198
1199     def get_tx_details(self, tx_hash):
1200         import datetime
1201         if not tx_hash: return ''
1202         tx = self.wallet.transactions.get(tx_hash)
1203         is_relevant, is_mine, v, fee = self.wallet.get_tx_value(tx)
1204         conf, timestamp = self.wallet.verifier.get_confirmations(tx_hash)
1205
1206         if timestamp:
1207             time_str = datetime.datetime.fromtimestamp(timestamp).isoformat(' ')[:-3]
1208         else:
1209             time_str = 'pending'
1210
1211         inputs = map(lambda x: x.get('address'), tx.inputs)
1212         outputs = map(lambda x: x.get('address'), tx.d['outputs'])
1213         tx_details = "Transaction Details" +"\n\n" \
1214             + "Transaction ID:\n" + tx_hash + "\n\n" \
1215             + "Status: %d confirmations\n"%conf
1216         if is_mine:
1217             if fee:
1218                 tx_details += "Amount sent: %s\n"% format_satoshis(v-fee, False) \
1219                               + "Transaction fee: %s\n"% format_satoshis(fee, False)
1220             else:
1221                 tx_details += "Amount sent: %s\n"% format_satoshis(v, False) \
1222                               + "Transaction fee: unknown\n"
1223         else:
1224             tx_details += "Amount received: %s\n"% format_satoshis(v, False) \
1225
1226         tx_details += "Date: %s\n\n"%time_str \
1227             + "Inputs:\n-"+ '\n-'.join(inputs) + "\n\n" \
1228             + "Outputs:\n-"+ '\n-'.join(outputs)
1229
1230         return tx_details
1231
1232
1233
1234     def newaddress_dialog(self, w):
1235
1236         title = "New Contact"
1237         dialog = Gtk.Dialog(title, parent=self.window,
1238                             flags=Gtk.DialogFlags.MODAL,
1239                             buttons= ("cancel", 0, "ok",1)  )
1240         dialog.show()
1241
1242         label = Gtk.HBox()
1243         label_label = Gtk.Label(label='Label:')
1244         label_label.set_size_request(120,10)
1245         label_label.show()
1246         label.pack_start(label_label, True, True, 0)
1247         label_entry = Gtk.Entry()
1248         label_entry.show()
1249         label.pack_start(label_entry, True, True, 0)
1250         label.show()
1251         dialog.vbox.pack_start(label, False, True, 5)
1252
1253         address = Gtk.HBox()
1254         address_label = Gtk.Label(label='Address:')
1255         address_label.set_size_request(120,10)
1256         address_label.show()
1257         address.pack_start(address_label, True, True, 0)
1258         address_entry = Gtk.Entry()
1259         address_entry.show()
1260         address.pack_start(address_entry, True, True, 0)
1261         address.show()
1262         dialog.vbox.pack_start(address, False, True, 5)
1263
1264         result = dialog.run()
1265         address = address_entry.get_text()
1266         label = label_entry.get_text()
1267         dialog.destroy()
1268
1269         if result == 1:
1270             if is_valid(address):
1271                 self.wallet.add_contact(address,label)
1272                 self.update_sending_tab()
1273             else:
1274                 errorDialog = Gtk.MessageDialog(
1275                     parent=self.window,
1276                     flags=Gtk.DialogFlags.MODAL,
1277                     buttons= Gtk.ButtonsType.CLOSE,
1278                     message_format = "Invalid address")
1279                 errorDialog.show()
1280                 errorDialog.run()
1281                 errorDialog.destroy()
1282
1283
1284
1285 class ElectrumGui():
1286
1287     def __init__(self, config, network):
1288         self.network = network
1289         self.config = config
1290
1291
1292     def main(self, url=None):
1293
1294         storage = WalletStorage(self.config)
1295         if not storage.file_exists:
1296             action = self.restore_or_create()
1297             if not action:
1298                 exit()
1299             self.wallet = wallet = Wallet(storage)
1300             gap = self.config.get('gap_limit', 5)
1301             if gap != 5:
1302                 wallet.gap_limit = gap
1303                 wallet.storage.put('gap_limit', gap, True)
1304
1305             if action == 'create':
1306                 seed = wallet.make_seed()
1307                 show_seed_dialog(seed, None)
1308                 r = change_password_dialog(False, None)
1309                 password = r[2] if r else None
1310                 wallet.add_seed(seed, password)
1311                 wallet.create_accounts(password)
1312                 wallet.synchronize()  # generate first addresses offline
1313
1314             elif action == 'restore':
1315                 seed = self.seed_dialog()
1316                 if not seed:
1317                     exit()
1318                 r = change_password_dialog(False, None)
1319                 password = r[2] if r else None
1320                 wallet.add_seed(seed, password)
1321                 wallet.create_accounts(password)
1322
1323             else:
1324                 exit()
1325         else:
1326             self.wallet = Wallet(storage)
1327             action = None
1328
1329         self.wallet.start_threads(self.network)
1330
1331         if action == 'restore':
1332             self.restore_wallet(wallet)
1333
1334         w = ElectrumWindow(self.wallet, self.config, self.network)
1335         if url: w.set_url(url)
1336         Gtk.main()
1337
1338     def restore_or_create(self):
1339         return restore_create_dialog()
1340
1341     def seed_dialog(self):
1342         return run_recovery_dialog()
1343
1344     def network_dialog(self):
1345         return run_network_dialog( self.network, parent=None )
1346
1347
1348     def restore_wallet(self, wallet):
1349
1350         dialog = Gtk.MessageDialog(
1351             parent = None,
1352             flags = Gtk.DialogFlags.MODAL,
1353             buttons = Gtk.ButtonsType.CANCEL,
1354             message_format = "Please wait..."  )
1355         dialog.show()
1356
1357         def recover_thread( wallet, dialog ):
1358             wallet.restore(lambda x:x)
1359             GObject.idle_add( dialog.destroy )
1360
1361         thread.start_new_thread( recover_thread, ( wallet, dialog ) )
1362         r = dialog.run()
1363         dialog.destroy()
1364         if r==Gtk.ResponseType.CANCEL: return False
1365         if not wallet.is_found():
1366             show_message("No transactions found for this seed")
1367
1368         return True