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