def __init__(self, parent: 'ElectrumSysWindow'):
CustomModel.__init__(self, parent, len(HistoryColumns))
Logger.__init__(self)
self.parent = parent
self.view = None # type: HistoryList
self.transactions = OrderedDictWithIndex()
self.tx_status_cache = {} # type: Dict[str, Tuple[int, str]]
def __init__(self, config: 'SimpleConfig', exctype, value, tb):
BaseCrashReporter.__init__(self, exctype, value, tb)
self.network = Network.get_instance()
self.config = config
QWidget.__init__(self)
self.setWindowTitle('ElectrumSys - ' + _('An Error Occurred'))
self.setMinimumSize(600, 300)
Logger.__init__(self)
main_box = QVBoxLayout()
heading = QLabel('<h2>' + BaseCrashReporter.CRASH_TITLE + '</h2>')
main_box.addWidget(heading)
main_box.addWidget(QLabel(BaseCrashReporter.CRASH_MESSAGE))
main_box.addWidget(QLabel(BaseCrashReporter.REQUEST_HELP_MESSAGE))
collapse_info = QPushButton(_("Show report contents"))
collapse_info.clicked.connect(
lambda: self.msg_box(QMessageBox.NoIcon,
self,
_("Report contents"),
self.get_report_string(),
rich_text=True))
main_box.addWidget(collapse_info)
main_box.addWidget(QLabel(BaseCrashReporter.DESCRIBE_ERROR_MESSAGE))
self.description_textfield = QTextEdit()
self.description_textfield.setFixedHeight(50)
self.description_textfield.setPlaceholderText(
self.USER_COMMENT_PLACEHOLDER)
main_box.addWidget(self.description_textfield)
main_box.addWidget(QLabel(BaseCrashReporter.ASK_CONFIRM_SEND))
buttons = QHBoxLayout()
report_button = QPushButton(_('Send Bug Report'))
report_button.clicked.connect(self.send_report)
report_button.setIcon(read_QIcon("tab_send.png"))
buttons.addWidget(report_button)
never_button = QPushButton(_('Never'))
never_button.clicked.connect(self.show_never)
buttons.addWidget(never_button)
close_button = QPushButton(_('Not Now'))
close_button.clicked.connect(self.close)
buttons.addWidget(close_button)
main_box.addLayout(buttons)
self.setLayout(main_box)
self.show()
def __init__(self, *, config: 'SimpleConfig', daemon: 'Daemon',
plugins: 'Plugins'):
BaseElectrumSysGui.__init__(self,
config=config,
daemon=daemon,
plugins=plugins)
Logger.__init__(self)
self.logger.debug('ElectrumSysGUI: initialising')
self.network = daemon.network
def __init__(self, imap_server, username, password, callback):
threading.Thread.__init__(self)
Logger.__init__(self)
self.daemon = True
self.username = username
self.password = password
self.imap_server = imap_server
self.on_receive = callback
self.M = None
self.reset_connect_wait()
def __init__(self, *, config: 'SimpleConfig'):
QObject.__init__(self)
Logger.__init__(self)
assert self._INSTANCE is None, "Exception_Hook is supposed to be a singleton"
self.config = config
self.wallet_types_seen = set() # type: Set[str]
sys.excepthook = self.handler
self._report_exception.connect(_show_window)
EarlyExceptionsQueue.set_hook_as_ready()
def __init__(self, text="", allow_multi=False, *, config: SimpleConfig):
ButtonsTextEdit.__init__(self, text)
Logger.__init__(self)
self.allow_multi = allow_multi
self.config = config
self.setReadOnly(False)
self.addButton("file.png", self.file_input, _("Read file"))
icon = "camera_white.png" if ColorScheme.dark_scheme else "camera_dark.png"
self.addButton(icon, self.qr_input, _("Read QR code"))
run_hook('scan_text_edit', self)
def __init__(self, main_window):
base.ExceptionHandler.__init__(self)
Logger.__init__(self)
self.main_window = main_window
if not main_window.electrumsys_config.get(BaseCrashReporter.config_key, default=True):
return
# For exceptions in Kivy:
base.ExceptionManager.add_handler(self)
# For everything else:
sys.excepthook = lambda exctype, value, tb: self.handle_exception(value)
EarlyExceptionsQueue.set_hook_as_ready()
def __init__(self, chan: AbstractChannel, app, **kwargs):
Popup.__init__(self, **kwargs)
Logger.__init__(self)
self.chan = chan
self.is_funded = chan.get_state() == ChannelState.FUNDED
self.can_be_deleted = chan.can_be_deleted()
self.funding_txid = chan.funding_outpoint.txid
self.app = app
self.short_id = format_short_channel_id(chan.short_channel_id)
self.capacity = self.app.format_amount_and_units(chan.get_capacity())
self.state = chan.get_state_for_GUI()
self.title = _('Channel Backup')
def __init__(self, handler, plugin, proto):
assert hasattr(self, 'tx_api') # ProtocolMixin already constructed?
HardwareClientBase.__init__(self, plugin=plugin)
self.proto = proto
self.device = plugin.device
self.handler = handler
self.tx_api = plugin
self.types = plugin.types
self.msg = None
self.creating_wallet = False
Logger.__init__(self)
self.used()
def __init__(self, app, lnaddr=None, msg=None):
Factory.Popup.__init__(self)
Logger.__init__(self)
self.app = app # type: ElectrumSysWindow
self.lnaddr = lnaddr
self.msg = msg
self.use_gossip = bool(self.app.network.channel_db)
if not self.use_gossip:
from electrumsys.lnworker import hardcoded_trampoline_nodes
self.trampolines = hardcoded_trampoline_nodes()
self.trampoline_names = list(self.trampolines.keys())
self.trampoline_index = 0
self.pubkey = ''
def __init__(self, transport, handler, plugin):
HardwareClientBase.__init__(self, plugin=plugin)
if plugin.is_outdated_fw_ignored():
TrezorClient.is_outdated = lambda *args, **kwargs: False
self.client = TrezorClient(transport, ui=self)
self.device = plugin.device
self.handler = handler
Logger.__init__(self)
self.msg = None
self.creating_wallet = False
self.in_flow = False
self.used()
def __init__(self, *, config: 'SimpleConfig', daemon: 'Daemon',
plugins: 'Plugins'):
set_language(config.get('language', get_default_language()))
BaseElectrumSysGui.__init__(self,
config=config,
daemon=daemon,
plugins=plugins)
Logger.__init__(self)
self.logger.info(
f"Qt GUI starting up... Qt={QtCore.QT_VERSION_STR}, PyQt={QtCore.PYQT_VERSION_STR}"
)
# Uncomment this call to verify objects are being properly
# GC-ed when windows are closed
#network.add_jobs([DebugMem([Abstract_Wallet, SPV, Synchronizer,
# ElectrumSysWindow], interval=5)])
QtCore.QCoreApplication.setAttribute(QtCore.Qt.AA_X11InitThreads)
if hasattr(QtCore.Qt, "AA_ShareOpenGLContexts"):
QtCore.QCoreApplication.setAttribute(
QtCore.Qt.AA_ShareOpenGLContexts)
if hasattr(QGuiApplication, 'setDesktopFileName'):
QGuiApplication.setDesktopFileName('electrumsys.desktop')
self.gui_thread = threading.current_thread()
self.windows = [] # type: List[ElectrumSysWindow]
self.efilter = OpenFileEventFilter(self.windows)
self.app = QElectrumSysApplication(sys.argv)
self.app.installEventFilter(self.efilter)
self.app.setWindowIcon(read_QIcon("electrumsys.png"))
self._cleaned_up = False
# timer
self.timer = QTimer(self.app)
self.timer.setSingleShot(False)
self.timer.setInterval(500) # msec
self.network_dialog = None
self.lightning_dialog = None
self.watchtower_dialog = None
self.network_updated_signal_obj = QNetworkUpdatedSignalObject()
self._num_wizards_in_progress = 0
self._num_wizards_lock = threading.Lock()
self.dark_icon = self.config.get("dark_icon", False)
self.tray = None
self._init_tray()
self.app.new_window_signal.connect(self.start_new_window)
self.app.quit_signal.connect(self.app.quit, Qt.QueuedConnection)
self.set_dark_theme_if_needed()
run_hook('init_qt', self)
def __init__(self, win: Union[ElectrumSysWindow, InstallWizard],
device: str):
QObject.__init__(self)
Logger.__init__(self)
assert win.gui_thread == threading.current_thread(
), 'must be called from GUI thread'
self.clear_signal.connect(self.clear_dialog)
self.error_signal.connect(self.error_dialog)
self.message_signal.connect(self.message_dialog)
self.passphrase_signal.connect(self.passphrase_dialog)
self.word_signal.connect(self.word_dialog)
self.query_signal.connect(self.win_query_choice)
self.yes_no_signal.connect(self.win_yes_no_question)
self.status_signal.connect(self._update_status)
self.win = win
self.device = device
self.dialog = None
self.done = threading.Event()
def __init__(self, win: 'ElectrumSysWindow'):
CompletionTextEdit.__init__(self)
ScanQRTextEdit.__init__(self, config=win.config)
Logger.__init__(self)
self.win = win
self.amount_edit = win.amount_e
self.setFont(QFont(MONOSPACE_FONT))
self.document().contentsChanged.connect(self.update_size)
self.heightMin = 0
self.heightMax = 150
self.c = None
self.textChanged.connect(self.check_text)
self.outputs = [] # type: List[PartialTxOutput]
self.errors = [] # type: List[PayToLineError]
self.is_pr = False
self.is_alias = False
self.update_size()
self.payto_scriptpubkey = None # type: Optional[bytes]
self.lightning_invoice = None
self.previous_payto = ''
def __init__(self, chan: Channel, app: 'ElectrumSysWindow', **kwargs):
Popup.__init__(self, **kwargs)
Logger.__init__(self)
self.is_closed = chan.is_closed()
self.can_be_deleted = chan.can_be_deleted()
self.app = app
self.chan = chan
self.title = _('Channel details')
self.node_id = bh2u(chan.node_id)
self.channel_id = bh2u(chan.channel_id)
self.funding_txid = chan.funding_outpoint.txid
self.short_id = format_short_channel_id(chan.short_channel_id)
self.capacity = self.app.format_amount_and_units(chan.get_capacity())
self.state = chan.get_state_for_GUI()
self.local_ctn = chan.get_latest_ctn(LOCAL)
self.remote_ctn = chan.get_latest_ctn(REMOTE)
self.local_csv = chan.config[LOCAL].to_self_delay
self.remote_csv = chan.config[REMOTE].to_self_delay
self.initiator = 'Local' if chan.constraints.is_initiator else 'Remote'
feerate_kw = chan.get_latest_feerate(LOCAL)
self.feerate = str(
quantize_feerate(Transaction.satperbyte_from_satperkw(feerate_kw)))
self.can_send = self.app.format_amount_and_units(
chan.available_to_spend(LOCAL) // 1000)
self.can_receive = self.app.format_amount_and_units(
chan.available_to_spend(REMOTE) // 1000)
self.is_open = chan.is_open()
closed = chan.get_closing_height()
if closed:
self.closing_txid, closing_height, closing_timestamp = closed
msg = messages.MSG_NON_TRAMPOLINE_CHANNEL_FROZEN_WITHOUT_GOSSIP
self.warning = '' if self.app.wallet.lnworker.channel_db or self.app.wallet.lnworker.is_trampoline_peer(
chan.node_id) else _('Warning') + ': ' + msg
self.is_frozen_for_sending = chan.is_frozen_for_sending()
self.is_frozen_for_receiving = chan.is_frozen_for_receiving()
self.update_action_dropdown()
def __init__(self, plugin, window):
QObject.__init__(self)
self.plugin = plugin
self.window = window
Logger.__init__(self)
def __init__(self, **kwargs):
CScreen.__init__(self, **kwargs)
Logger.__init__(self)
self.is_max = False
def __init__(self):
QThread.__init__(self)
Logger.__init__(self)
self.network = Network.get_instance()
def __init__(self, parent, *, config: SimpleConfig):
''' Note: make sure parent is a "top_level_window()" as per
MessageBoxMixin API else bad things can happen on macOS. '''
QDialog.__init__(self, parent=parent)
Logger.__init__(self)
self.validator: AbstractQrReaderValidator = None
self.frame_id: int = 0
self.qr_crop: QRect = None
self.qrreader_res: List[QrCodeResult] = []
self.validator_res: QrReaderValidatorResult = None
self.last_stats_time: float = 0.0
self.frame_counter: int = 0
self.qr_frame_counter: int = 0
self.last_qr_scan_ts: float = 0.0
self.camera: QCamera = None
self._error_message: str = None
self._ok_done: bool = False
self.camera_sc_conn = None
self.resolution: QSize = None
self.config = config
# Try to get the QR reader for this system
self.qrreader = get_qr_reader()
if not self.qrreader:
raise MissingQrDetectionLib(
_("The platform QR detection library is not available."))
# Set up the window, add the maximize button
flags = self.windowFlags()
flags = flags | Qt.WindowMaximizeButtonHint
self.setWindowFlags(flags)
self.setWindowTitle(_("Scan QR Code"))
self.setWindowModality(
Qt.WindowModal if parent else Qt.ApplicationModal)
# Create video widget and fixed aspect ratio layout to contain it
self.video_widget = QrReaderVideoWidget()
self.video_overlay = QrReaderVideoOverlay()
self.video_layout = FixedAspectRatioLayout()
self.video_layout.addWidget(self.video_widget)
self.video_layout.addWidget(self.video_overlay)
# Create root layout and add the video widget layout to it
vbox = QVBoxLayout()
self.setLayout(vbox)
vbox.setContentsMargins(0, 0, 0, 0)
vbox.addLayout(self.video_layout)
self.lowres_label = QLabel(
_("Note: This camera generates frames of relatively low resolution; QR scanning accuracy may be affected"
))
self.lowres_label.setWordWrap(True)
self.lowres_label.setAlignment(Qt.AlignVCenter | Qt.AlignHCenter)
vbox.addWidget(self.lowres_label)
self.lowres_label.setHidden(True)
# Create a layout for the controls
controls_layout = QHBoxLayout()
controls_layout.addStretch(2)
controls_layout.setContentsMargins(10, 10, 10, 10)
controls_layout.setSpacing(10)
vbox.addLayout(controls_layout)
# Flip horizontally checkbox with default coming from global config
self.flip_x = QCheckBox()
self.flip_x.setText(_("&Flip horizontally"))
self.flip_x.setChecked(bool(self.config.get('qrreader_flip_x', True)))
self.flip_x.stateChanged.connect(self._on_flip_x_changed)
controls_layout.addWidget(self.flip_x)
close_but = QPushButton(_("&Close"))
close_but.clicked.connect(self.reject)
controls_layout.addWidget(close_but)
# Create the video surface and receive events when new frames arrive
self.video_surface = QrReaderVideoSurface(self)
self.video_surface.frame_available.connect(self._on_frame_available)
# Create the crop blur effect
self.crop_blur_effect = QrReaderCropBlurEffect(self)
self.image_effect = ImageGraphicsEffect(self, self.crop_blur_effect)
# Note these should stay as queued connections becasue we use the idiom
# self.reject() and self.accept() in this class to kill the scan --
# and we do it from within callback functions. If you don't use
# queued connections here, bad things can happen.
self.finished.connect(self._boilerplate_cleanup, Qt.QueuedConnection)
self.finished.connect(self._on_finished, Qt.QueuedConnection)
def __init__(self, user_agent=None, base_url='https://api.trustedcoin.com/2/'):
self.base_url = base_url
self.debug = False
self.user_agent = user_agent
Logger.__init__(self)
