sys.exit(0)
from decimal import Decimal as D
-from electrum.util import get_resource_path as rsrc
-from electrum.bitcoin import is_valid
-from electrum.i18n import _
+from electrum_nvc.util import get_resource_path as rsrc
+from electrum_nvc.bitcoin import is_valid
+from electrum_nvc.i18n import _
import decimal
import json
import os.path
import random
import re
import time
-from electrum.wallet import Wallet, WalletStorage
+from electrum_nvc.wallet import Wallet, WalletStorage
import webbrowser
import history_widget
import receiving_widget
-from electrum import util
-import csv
+from electrum_nvc import util
import datetime
-from electrum.version import ELECTRUM_VERSION as electrum_version
-from electrum.util import format_satoshis, age
+from electrum_nvc.version import ELECTRUM_VERSION as electrum_version
+from electrum_nvc.util import format_satoshis, age
from main_window import ElectrumWindow
import shutil
from util import *
-bitcoin = lambda v: v * 100000000
+bitcoin = lambda v: v * 1000000
def IconButton(filename, parent=None):
pixmap = QPixmap(filename)
icon = QIcon(pixmap)
return QPushButton(icon, "", parent)
-class Timer(QThread):
- def run(self):
- while True:
- self.emit(SIGNAL('timersignal'))
- time.sleep(0.5)
def resize_line_edit_width(line_edit, text_input):
metrics = QFontMetrics(qApp.font())
return theme_paths
-def csv_transaction(wallet):
- try:
- select_export = _('Select file to export your wallet transactions to')
- fileName = QFileDialog.getSaveFileName(QWidget(), select_export, os.path.expanduser('~/electrum-history.csv'), "*.csv")
- if fileName:
- with open(fileName, "w+") as csvfile:
- transaction = csv.writer(csvfile)
- transaction.writerow(["transaction_hash","label", "confirmations", "value", "fee", "balance", "timestamp"])
- for item in wallet.get_tx_history():
- tx_hash, confirmations, is_mine, value, fee, balance, timestamp = item
- if confirmations:
- if timestamp is not None:
- try:
- time_string = datetime.datetime.fromtimestamp(timestamp).isoformat(' ')[:-3]
- except [RuntimeError, TypeError, NameError] as reason:
- time_string = "unknown"
- pass
- else:
- time_string = "unknown"
- else:
- time_string = "pending"
-
- if value is not None:
- value_string = format_satoshis(value, True, wallet.num_zeros)
- else:
- value_string = '--'
-
- if fee is not None:
- fee_string = format_satoshis(fee, True, wallet.num_zeros)
- else:
- fee_string = '0'
-
- if tx_hash:
- label, is_default_label = wallet.get_label(tx_hash)
- else:
- label = ""
-
- balance_string = format_satoshis(balance, False, wallet.num_zeros)
- transaction.writerow([tx_hash, label, confirmations, value_string, fee_string, balance_string, time_string])
- QMessageBox.information(None,"CSV Export created", "Your CSV export has been successfully created.")
- except (IOError, os.error), reason:
- export_error_label = _("Electrum was unable to produce a transaction export.")
- QMessageBox.critical(None,_("Unable to create csv"), export_error_label + "\n" + str(reason))
-
class TransactionWindow(QDialog):
self.actuator = actuator
self.config = config
self.btc_balance = None
+ self.use_exchanges = ["Blockchain", "CoinDesk"]
self.quote_currencies = ["BRL", "CNY", "EUR", "GBP", "RUB", "USD"]
self.actuator.set_configured_currency(self.set_quote_currency)
+ self.actuator.set_configured_exchange(self.set_exchange)
# Needed because price discovery is done in a different thread
# which needs to be sent back to this main one to update the GUI
# Bitcoin address code
self.address_input = QLineEdit()
- self.address_input.setPlaceholderText(_("Enter a Bitcoin address or contact"))
+ self.address_input.setPlaceholderText(_("Enter a Novacoin address or contact"))
self.address_input.setObjectName("address_input")
self.address_input.setFocusPolicy(Qt.ClickFocus)
self.address_input.textChanged.connect(self.address_field_changed)
resize_line_edit_width(self.address_input,
- "1BtaFUr3qVvAmwrsuDuu5zk6e4s2rxd2Gy")
+ "4LJgtjeXMjLA6nVzYMJh1LEkwxMFsRtnP4")
self.address_completions = QStringListModel()
address_completer = QCompleter(self.address_input)
self.toggle_receiving_layout(show_hist)
self.setWindowIcon(QIcon(":icons/electrum.png"))
- self.setWindowTitle("Electrum")
+ self.setWindowTitle("Electrum-NVC")
self.setWindowFlags(Qt.Window|Qt.MSWindowsFixedSizeDialogHint)
self.layout().setSizeConstraint(QLayout.SetFixedSize)
self.setObjectName("main_window")
- self.show()
def context_menu(self):
view_menu = QMenu()
def toggle_theme(self, theme_name):
- old_path = QDir.currentPath()
self.actuator.change_theme(theme_name)
# Recompute style globally
qApp.style().unpolish(self)
qApp.style().polish(self)
- QDir.setCurrent(old_path)
def closeEvent(self, event):
g = self.geometry()
self.config.set_key("winpos-lite", [g.left(),g.top(),g.width(),g.height()],True)
-
- super(MiniWindow, self).closeEvent(event)
+ self.actuator.g.closeEvent(event)
qApp.quit()
- def set_payment_fields(self, dest_address, amount):
+ def pay_from_URI(self, URI):
+ try:
+ dest_address, amount, label, message, request_url = util.parse_URI(URI)
+ except:
+ return
self.address_input.setText(dest_address)
self.address_field_changed(dest_address)
- self.amount_input.setText(amount)
+ self.amount_input.setText(str(amount))
def activate(self):
pass
def deactivate(self):
pass
+ def set_exchange(self, use_exchange):
+ if use_exchange not in self.use_exchanges:
+ return
+ self.use_exchanges.remove(use_exchange)
+ self.use_exchanges.insert(0, use_exchange)
+ self.refresh_balance()
+
def set_quote_currency(self, currency):
"""Set and display the fiat currency country."""
if currency not in self.quote_currencies:
def create_quote_text(self, btc_balance):
"""Return a string copy of the amount fiat currency the
user has in bitcoins."""
- from electrum.plugins import run_hook
+ from electrum_nvc.plugins import run_hook
r = {}
- run_hook('set_quote_text', btc_balance, r)
+ run_hook('get_fiat_balance_text', btc_balance, r)
return r.get(0,'')
def send(self):
self.close()
def setup(self, address):
- label = QLabel(_("Copied your Bitcoin address to the clipboard!"))
+ label = QLabel(_("Copied your Novacoin address to the clipboard!"))
address_display = QLineEdit(address)
address_display.setReadOnly(True)
resize_line_edit_width(address_display, address)
main_layout.addWidget(address_display)
self.setMouseTracking(True)
- self.setWindowTitle("Electrum - " + _("Receive Bitcoin payment"))
+ self.setWindowTitle("Electrum - " + _("Receive Novacoin payment"))
self.setWindowFlags(Qt.Window|Qt.FramelessWindowHint|
Qt.MSWindowsFixedSizeDialogHint)
self.layout().setSizeConstraint(QLayout.SetFixedSize)
self.g = main_window
self.theme_name = self.g.config.get('litegui_theme','Cleanlook')
self.themes = load_theme_paths()
+ self.load_theme()
def load_theme(self):
"""Load theme retrieved from wallet file."""
except KeyError:
util.print_error("Theme not found!", self.theme_name)
return
- QDir.setCurrent(os.path.join(theme_prefix, theme_path))
- with open(rsrc("style.css")) as style_file:
+ full_theme_path = "%s/%s/style.css" % (theme_prefix, theme_path)
+ with open(full_theme_path) as style_file:
qApp.setStyleSheet(style_file.read())
def theme_names(self):
def change_theme(self, theme_name):
"""Change theme."""
self.theme_name = theme_name
- self.config.set_key('litegui_theme',theme_name)
+ self.g.config.set_key('litegui_theme',theme_name)
self.load_theme()
+
+ def set_configured_exchange(self, set_exchange):
+ use_exchange = self.g.config.get('use_exchange')
+ if use_exchange is not None:
+ set_exchange(use_exchange)
def set_configured_currency(self, set_quote_currency):
"""Set the inital fiat currency conversion country (USD/EUR/GBP) in
if currency is not None:
set_quote_currency(currency)
+ def set_config_exchange(self, conversion_exchange):
+ self.g.config.set_key('exchange',conversion_exchange,True)
+ self.g.update_status()
+
def set_config_currency(self, conversion_currency):
"""Change the wallet fiat currency country."""
- self.g.config.set_key('conversion_currency',conversion_currency,True)
+ self.g.config.set_key('currency',conversion_currency,True)
+ self.g.update_status()
def copy_address(self, receive_popup):
"""Copy the wallet addresses into the client."""
if dest_address is None or not is_valid(dest_address):
QMessageBox.warning(parent_window, _('Error'),
- _('Invalid Bitcoin Address') + ':\n' + address, _('OK'))
+ _('Invalid Novacoin Address') + ':\n' + address, _('OK'))
return False
amount = D(unicode(amount)) * (10*self.g.decimal_point)
password = None
fee = 0
- # 0.1 BTC = 10000000
+ # 0.1 NVC = 100000
if amount < bitcoin(1) / 10:
- # 0.001 BTC
+ # 0.001 NVC
fee = bitcoin(1) / 1000
try:
tx = self.g.wallet.mktx([(dest_address, amount)], password, fee)
- except BaseException as error:
+ except Exception as error:
QMessageBox.warning(parent_window, _('Error'), str(error), _('OK'))
return False
- if tx.is_complete:
+ if tx.is_complete():
h = self.g.wallet.send_tx(tx)
self.waiting_dialog(lambda: False if self.g.wallet.tx_event.isSet() else _("Sending transaction, please wait..."))
- status, message = self.g.wallet.receive_tx(h)
+ status, message = self.g.wallet.receive_tx(h, tx)
if not status:
import tempfile
with open(fileName,'w') as f:
f.write(json.dumps(tx.as_dict(),indent=4) + '\n')
QMessageBox.information(QWidget(), _('Unsigned transaction created'), _("Unsigned transaction was saved to file:") + " " +fileName, _('OK'))
- except BaseException as e:
+ except Exception as e:
QMessageBox.warning(QWidget(), _('Error'), _('Could not write transaction to file: %s' % e), _('OK'))
return True
self.network = main_window.network
self.window = mini_window
- self.network.register_callback('updated',self.update_callback)
- self.network.register_callback('connected', self.update_callback)
- self.network.register_callback('disconnected', self.update_callback)
+ if self.network:
+ self.network.register_callback('updated',self.update_callback)
+ self.network.register_callback('connected', self.update_callback)
+ self.network.register_callback('disconnected', self.update_callback)
self.state = None
self.emit(SIGNAL("updatesignal()"))
def update(self):
- if not self.network.interface:
+ if not self.network:
+ self.initializing()
+ elif not self.network.interface:
self.initializing()
elif not self.network.interface.is_connected:
self.connecting()
self.update_balance()
self.update_completions()
self.update_history()
+ self.window.receiving.update_list()
+
def initializing(self):
if self.state == self.INITIALIZING: