import RNS import collections import os import shutil import time import nomadnet import LXMF import urwid from datetime import datetime, timedelta from nomadnet.Directory import DirectoryEntry from nomadnet.Conversation import ConversationMessage from nomadnet.util import strip_modifiers from nomadnet.util import sanitize_name def relative_time(timestamp): now = time.time() delta = now - timestamp if delta < 0: return "just now" elif delta < 60: return "just now" elif delta < 3600: m = int(delta / 60) return str(m)+"m ago" elif delta < 86400: h = int(delta / 3600) return str(h)+"h ago" elif delta < 172800: return "yesterday" elif delta < 604800: d = int(delta / 86400) return str(d)+"d ago" elif delta < 2592000: w = int(delta / 604800) return str(w)+"w ago" else: return datetime.fromtimestamp(timestamp).strftime("%Y-%m-%d") def _format_size(size): if size < 1024: return str(size)+" B" elif size < 1048576: return str(round(size/1024, 1))+" KB" else: return str(round(size/1048576, 1))+" MB" from nomadnet.vendor.additional_urwid_widgets import IndicativeListBox class ConversationListDisplayShortcuts(): def __init__(self, app): self.app = app self.widget = urwid.AttrMap(urwid.Text("[C-e] Peer Info [C-x] Delete [C-r] Sync [C-n] New [C-u] Ingest URI [C-o] Sort [C-g] Fullscreen"), "shortcutbar") class ConversationDisplayShortcuts(): def __init__(self, app): self.app = app self.widget = urwid.AttrMap(urwid.Text("[C-d] Send [C-p] Paper Msg [C-t] Title [C-a] Attach [C-s] Save [C-k] Clear [C-w] Close [C-u] Purge [C-x] Clear History [C-o] Sort"), "shortcutbar") class ConversationsArea(urwid.LineBox): def keypress(self, size, key): if key == "ctrl e": self.delegate.edit_selected_in_directory() elif key == "ctrl x": self.delegate.delete_selected_conversation() elif key == "ctrl n": self.delegate.new_conversation() elif key == "ctrl u": self.delegate.ingest_lxm_uri() elif key == "ctrl r": self.delegate.sync_conversations() elif key == "ctrl g": self.delegate.toggle_fullscreen() elif key == "ctrl o": self.delegate.toggle_list_sort() elif key == "tab": self.delegate.app.ui.main_display.frame.focus_position = "header" elif key == "up" and (self.delegate.ilb.first_item_is_selected() or self.delegate.ilb.body_is_empty()): self.delegate.app.ui.main_display.frame.focus_position = "header" else: return super(ConversationsArea, self).keypress(size, key) class DialogLineBox(urwid.LineBox): def keypress(self, size, key): if key == "esc": if hasattr(self.delegate, "update_conversation_list"): self.delegate.update_conversation_list() elif hasattr(self.delegate, "dialog_active"): self.delegate.dialog_active = False self.delegate.conversation_changed(None) else: return super(DialogLineBox, self).keypress(size, key) class ConversationsDisplay(): list_width = 0.33 given_list_width = 52 cached_conversation_widgets = {} SORT_RECENT = 0 SORT_NAME = 1 def __init__(self, app): self.app = app self.dialog_open = False self.sync_dialog = None self.currently_displayed_conversation = None self.list_sort_mode = ConversationsDisplay.SORT_RECENT def disp_list_shortcuts(sender, arg1, arg2): self.shortcuts_display = self.list_shortcuts self.app.ui.main_display.update_active_shortcuts() self.update_listbox() self.columns_widget = urwid.Columns( [ # (urwid.WEIGHT, ConversationsDisplay.list_width, self.listbox), # (urwid.WEIGHT, 1-ConversationsDisplay.list_width, self.make_conversation_widget(None)) (ConversationsDisplay.given_list_width, self.listbox), (urwid.WEIGHT, 1, self.make_conversation_widget(None)) ], dividechars=0, focus_column=0, box_columns=[0] ) self.list_shortcuts = ConversationListDisplayShortcuts(self.app) self.editor_shortcuts = ConversationDisplayShortcuts(self.app) self.shortcuts_display = self.list_shortcuts self.widget = self.columns_widget self._pending_actions = collections.deque() self._wake_fd = None try: self._wake_fd = self.app.ui.loop.watch_pipe(self._process_pending) except Exception: pass nomadnet.Conversation.created_callback = lambda: self._wake(self.update_conversation_list) def _process_pending(self, data): while True: try: action = self._pending_actions.popleft() except IndexError: break try: action() except Exception as e: RNS.log("Conversations UI action failed: "+str(e), RNS.LOG_ERROR) return True def _wake(self, action): self._pending_actions.append(action) if self._wake_fd is not None: try: os.write(self._wake_fd, b".") return except Exception: pass try: self.app.ui.loop.set_alarm_in(0.0, lambda l, d: self._process_pending(None)) except Exception: pass def focus_change_event(self): if not self.dialog_open: self.update_conversation_list() def toggle_list_sort(self): if self.list_sort_mode == ConversationsDisplay.SORT_RECENT: self.list_sort_mode = ConversationsDisplay.SORT_NAME else: self.list_sort_mode = ConversationsDisplay.SORT_RECENT self.update_conversation_list() def update_listbox(self): conversations = self.app.conversations() if self.list_sort_mode == ConversationsDisplay.SORT_NAME: conversations.sort(key=lambda e: (e[3].lower(), e[0])) conversation_list_widgets = [] for conversation in conversations: conversation_list_widgets.append(self.conversation_list_widget(conversation)) self.list_widgets = conversation_list_widgets self.ilb = IndicativeListBox( self.list_widgets, on_selection_change=self.conversation_list_selection, initialization_is_selection_change=False, highlight_offFocus="list_off_focus" ) self.listbox = ConversationsArea(urwid.Filler(self.ilb, height=urwid.RELATIVE_100), title="Conversations") self.listbox.delegate = self def delete_selected_conversation(self): self.dialog_open = True item = self.ilb.get_selected_item() if item == None: return source_hash = item.source_hash def dismiss_dialog(sender): self.update_conversation_list() self.dialog_open = False def confirmed(sender): self.dialog_open = False self.delete_conversation(source_hash) nomadnet.Conversation.delete_conversation(source_hash, self.app) self.update_conversation_list() dialog = DialogLineBox( urwid.Pile([ urwid.Text( "Delete conversation with\n"+self.app.directory.simplest_display_str(bytes.fromhex(source_hash))+"\n", align=urwid.CENTER, ), urwid.Columns([ (urwid.WEIGHT, 0.45, urwid.Button("Yes", on_press=confirmed)), (urwid.WEIGHT, 0.1, urwid.Text("")), (urwid.WEIGHT, 0.45, urwid.Button("No", on_press=dismiss_dialog)), ]) ]), title="?" ) dialog.delegate = self bottom = self.listbox overlay = urwid.Overlay( dialog, bottom, align=urwid.CENTER, width=urwid.RELATIVE_100, valign=urwid.MIDDLE, height=urwid.PACK, left=2, right=2, ) # options = self.columns_widget.options(urwid.WEIGHT, ConversationsDisplay.list_width) options = self.columns_widget.options(urwid.GIVEN, ConversationsDisplay.given_list_width) self.columns_widget.contents[0] = (overlay, options) def edit_selected_in_directory(self): g = self.app.ui.glyphs self.dialog_open = True item = self.ilb.get_selected_item() if item == None: return source_hash_text = item.source_hash display_name = self.ilb.get_selected_item().display_name if display_name == None: display_name = "" e_id = urwid.Edit(caption="Addr : ",edit_text=source_hash_text) t_id = urwid.Text("Addr : "+source_hash_text) e_name = urwid.Edit(caption="Name : ",edit_text=display_name) selected_id_widget = t_id untrusted_selected = False unknown_selected = True trusted_selected = False direct_selected = True propagated_selected = False try: if self.app.directory.find(bytes.fromhex(source_hash_text)): trust_level = self.app.directory.trust_level(bytes.fromhex(source_hash_text)) if trust_level == DirectoryEntry.UNTRUSTED: untrusted_selected = True unknown_selected = False trusted_selected = False elif trust_level == DirectoryEntry.UNKNOWN: untrusted_selected = False unknown_selected = True trusted_selected = False elif trust_level == DirectoryEntry.TRUSTED: untrusted_selected = False unknown_selected = False trusted_selected = True if self.app.directory.preferred_delivery(bytes.fromhex(source_hash_text)) == DirectoryEntry.PROPAGATED: direct_selected = False propagated_selected = True except Exception as e: pass trust_button_group = [] r_untrusted = urwid.RadioButton(trust_button_group, "Untrusted", state=untrusted_selected) r_unknown = urwid.RadioButton(trust_button_group, "Unknown", state=unknown_selected) r_trusted = urwid.RadioButton(trust_button_group, "Trusted", state=trusted_selected) method_button_group = [] r_direct = urwid.RadioButton(method_button_group, "Deliver directly", state=direct_selected) r_propagated = urwid.RadioButton(method_button_group, "Use propagation nodes", state=propagated_selected) def dismiss_dialog(sender): self.update_conversation_list() self.dialog_open = False def confirmed(sender): try: display_name = e_name.get_edit_text() source_hash = bytes.fromhex(e_id.get_edit_text()) trust_level = DirectoryEntry.UNTRUSTED if r_unknown.state == True: trust_level = DirectoryEntry.UNKNOWN elif r_trusted.state == True: trust_level = DirectoryEntry.TRUSTED delivery = DirectoryEntry.DIRECT if r_propagated.state == True: delivery = DirectoryEntry.PROPAGATED entry = DirectoryEntry(source_hash, display_name, trust_level, preferred_delivery=delivery) self.app.directory.remember(entry) self.update_conversation_list() self.dialog_open = False self.app.ui.main_display.sub_displays.network_display.directory_change_callback() except Exception as e: RNS.log("Could not save directory entry. The contained exception was: "+str(e), RNS.LOG_VERBOSE) if not dialog_pile.error_display: dialog_pile.error_display = True options = dialog_pile.options(height_type=urwid.PACK) dialog_pile.contents.append((urwid.Text(""), options)) dialog_pile.contents.append(( urwid.Text(("error_text", "Could not save entry. Check your input."), align=urwid.CENTER), options,) ) source_is_known = self.app.directory.is_known(bytes.fromhex(source_hash_text)) if source_is_known: known_section = urwid.Divider(g["divider1"]) else: def query_action(sender, user_data): self.close_conversation_by_hash(user_data) nomadnet.Conversation.query_for_peer(user_data) options = dialog_pile.options(height_type=urwid.PACK) dialog_pile.contents = [ (urwid.Text("Query sent"), options), (urwid.Button("OK", on_press=dismiss_dialog), options) ] query_button = urwid.Button("Query network for keys", on_press=query_action, user_data=source_hash_text) known_section = urwid.Pile([ urwid.Divider(g["divider1"]), urwid.Text(g["info"]+"\n", align=urwid.CENTER), urwid.Text( "The identity of this peer is not known, and you cannot currently send messages to it. " "You can query the network to obtain the identity.\n", align=urwid.CENTER, ), query_button, urwid.Divider(g["divider1"]), ]) dialog_pile = urwid.Pile([ selected_id_widget, e_name, urwid.Divider(g["divider1"]), r_untrusted, r_unknown, r_trusted, urwid.Divider(g["divider1"]), r_direct, r_propagated, known_section, urwid.Columns([ (urwid.WEIGHT, 0.45, urwid.Button("Save", on_press=confirmed)), (urwid.WEIGHT, 0.1, urwid.Text("")), (urwid.WEIGHT, 0.45, urwid.Button("Back", on_press=dismiss_dialog)), ]) ]) dialog_pile.error_display = False dialog = DialogLineBox(dialog_pile, title="Peer Info") dialog.delegate = self bottom = self.listbox overlay = urwid.Overlay( dialog, bottom, align=urwid.CENTER, width=urwid.RELATIVE_100, valign=urwid.MIDDLE, height=urwid.PACK, left=2, right=2, ) # options = self.columns_widget.options(urwid.WEIGHT, ConversationsDisplay.list_width) options = self.columns_widget.options(urwid.GIVEN, ConversationsDisplay.given_list_width) self.columns_widget.contents[0] = (overlay, options) def new_conversation(self): self.dialog_open = True source_hash = "" display_name = "" e_id = urwid.Edit(caption="Addr : ",edit_text=source_hash) e_name = urwid.Edit(caption="Name : ",edit_text=display_name) trust_button_group = [] r_untrusted = urwid.RadioButton(trust_button_group, "Untrusted") r_unknown = urwid.RadioButton(trust_button_group, "Unknown", state=True) r_trusted = urwid.RadioButton(trust_button_group, "Trusted") def dismiss_dialog(sender): self.update_conversation_list() self.dialog_open = False def confirmed(sender): try: existing_conversations = nomadnet.Conversation.conversation_list(self.app) display_name = e_name.get_edit_text() source_hash_text = e_id.get_edit_text().strip() source_hash = bytes.fromhex(source_hash_text) trust_level = DirectoryEntry.UNTRUSTED if r_unknown.state == True: trust_level = DirectoryEntry.UNKNOWN elif r_trusted.state == True: trust_level = DirectoryEntry.TRUSTED if not source_hash in [c[0] for c in existing_conversations]: entry = DirectoryEntry(source_hash, display_name, trust_level) self.app.directory.remember(entry) new_conversation = nomadnet.Conversation(source_hash_text, nomadnet.NomadNetworkApp.get_shared_instance(), initiator=True) self.update_conversation_list() self.display_conversation(source_hash_text) self.dialog_open = False except Exception as e: RNS.log("Could not start conversation. The contained exception was: "+str(e), RNS.LOG_VERBOSE) if not dialog_pile.error_display: dialog_pile.error_display = True options = dialog_pile.options(height_type=urwid.PACK) dialog_pile.contents.append((urwid.Text(""), options)) dialog_pile.contents.append(( urwid.Text( ("error_text", "Could not start conversation. Check your input."), align=urwid.CENTER, ), options, )) dialog_pile = urwid.Pile([ e_id, e_name, urwid.Text(""), r_untrusted, r_unknown, r_trusted, urwid.Text(""), urwid.Columns([ (urwid.WEIGHT, 0.45, urwid.Button("Create", on_press=confirmed)), (urwid.WEIGHT, 0.1, urwid.Text("")), (urwid.WEIGHT, 0.45, urwid.Button("Back", on_press=dismiss_dialog)), ]) ]) dialog_pile.error_display = False dialog = DialogLineBox(dialog_pile, title="New Conversation") dialog.delegate = self bottom = self.listbox overlay = urwid.Overlay( dialog, bottom, align=urwid.CENTER, width=urwid.RELATIVE_100, valign=urwid.MIDDLE, height=urwid.PACK, left=2, right=2, ) # options = self.columns_widget.options(urwid.WEIGHT, ConversationsDisplay.list_width) options = self.columns_widget.options(urwid.GIVEN, ConversationsDisplay.given_list_width) self.columns_widget.contents[0] = (overlay, options) def ingest_lxm_uri(self): self.dialog_open = True lxm_uri = "" e_uri = urwid.Edit(caption="URI : ",edit_text=lxm_uri) def dismiss_dialog(sender): self.update_conversation_list() self.dialog_open = False def confirmed(sender): try: local_delivery_signal = "local_delivery_occurred" duplicate_signal = "duplicate_lxm" lxm_uri = e_uri.get_edit_text().strip() ingest_result = self.app.message_router.ingest_lxm_uri( lxm_uri, signal_local_delivery=local_delivery_signal, signal_duplicate=duplicate_signal ) if ingest_result == False: raise ValueError("The URI contained no decodable messages") elif ingest_result == local_delivery_signal: rdialog_pile = urwid.Pile([ urwid.Text("Message was decoded, decrypted successfully, and added to your conversation list."), urwid.Text(""), urwid.Columns([ (urwid.WEIGHT, 0.6, urwid.Text("")), (urwid.WEIGHT, 0.4, urwid.Button("OK", on_press=dismiss_dialog)), ]) ]) rdialog_pile.error_display = False rdialog = DialogLineBox(rdialog_pile, title="Ingest message URI") rdialog.delegate = self bottom = self.listbox roverlay = urwid.Overlay( rdialog, bottom, align=urwid.CENTER, width=urwid.RELATIVE_100, valign=urwid.MIDDLE, height=urwid.PACK, left=2, right=2, ) options = self.columns_widget.options(urwid.GIVEN, ConversationsDisplay.given_list_width) self.columns_widget.contents[0] = (roverlay, options) elif ingest_result == duplicate_signal: rdialog_pile = urwid.Pile([ urwid.Text("The decoded message has already been processed by the LXMF Router, and will not be ingested again."), urwid.Text(""), urwid.Columns([ (urwid.WEIGHT, 0.6, urwid.Text("")), (urwid.WEIGHT, 0.4, urwid.Button("OK", on_press=dismiss_dialog)), ]) ]) rdialog_pile.error_display = False rdialog = DialogLineBox(rdialog_pile, title="Ingest message URI") rdialog.delegate = self bottom = self.listbox roverlay = urwid.Overlay( rdialog, bottom, align=urwid.CENTER, width=urwid.RELATIVE_100, valign=urwid.MIDDLE, height=urwid.PACK, left=2, right=2, ) options = self.columns_widget.options(urwid.GIVEN, ConversationsDisplay.given_list_width) self.columns_widget.contents[0] = (roverlay, options) else: if self.app.enable_node: propagation_text = "The decoded message was not addressed to this LXMF address, but has been added to the propagation node queues, and will be distributed on the propagation network." else: propagation_text = "The decoded message was not addressed to this LXMF address, and has been discarded." rdialog_pile = urwid.Pile([ urwid.Text(propagation_text), urwid.Text(""), urwid.Columns([ (urwid.WEIGHT, 0.6, urwid.Text("")), (urwid.WEIGHT, 0.4, urwid.Button("OK", on_press=dismiss_dialog)), ]) ]) rdialog_pile.error_display = False rdialog = DialogLineBox(rdialog_pile, title="Ingest message URI") rdialog.delegate = self bottom = self.listbox roverlay = urwid.Overlay( rdialog, bottom, align=urwid.CENTER, width=urwid.RELATIVE_100, valign=urwid.MIDDLE, height=urwid.PACK, left=2, right=2, ) options = self.columns_widget.options(urwid.GIVEN, ConversationsDisplay.given_list_width) self.columns_widget.contents[0] = (roverlay, options) except Exception as e: RNS.log("Could not ingest LXM URI. The contained exception was: "+str(e), RNS.LOG_VERBOSE) if not dialog_pile.error_display: dialog_pile.error_display = True options = dialog_pile.options(height_type=urwid.PACK) dialog_pile.contents.append((urwid.Text(""), options)) dialog_pile.contents.append((urwid.Text(("error_text", "Could ingest LXM from URI data. Check your input."), align=urwid.CENTER), options)) dialog_pile = urwid.Pile([ e_uri, urwid.Text(""), urwid.Columns([ (urwid.WEIGHT, 0.45, urwid.Button("Ingest", on_press=confirmed)), (urwid.WEIGHT, 0.1, urwid.Text("")), (urwid.WEIGHT, 0.45, urwid.Button("Back", on_press=dismiss_dialog)), ]) ]) dialog_pile.error_display = False dialog = DialogLineBox(dialog_pile, title="Ingest message URI") dialog.delegate = self bottom = self.listbox overlay = urwid.Overlay( dialog, bottom, align=urwid.CENTER, width=urwid.RELATIVE_100, valign=urwid.MIDDLE, height=urwid.PACK, left=2, right=2, ) options = self.columns_widget.options(urwid.GIVEN, ConversationsDisplay.given_list_width) self.columns_widget.contents[0] = (overlay, options) def delete_conversation(self, source_hash): if source_hash in ConversationsDisplay.cached_conversation_widgets: conversation = ConversationsDisplay.cached_conversation_widgets[source_hash] self.close_conversation(conversation) def toggle_fullscreen(self): if ConversationsDisplay.given_list_width != 0: self.saved_list_width = ConversationsDisplay.given_list_width ConversationsDisplay.given_list_width = 0 else: ConversationsDisplay.given_list_width = self.saved_list_width self.update_conversation_list() def sync_conversations(self): g = self.app.ui.glyphs self.dialog_open = True def dismiss_dialog(sender): self.dialog_open = False self.sync_dialog = None self.update_conversation_list() if self.app.message_router.propagation_transfer_state >= LXMF.LXMRouter.PR_COMPLETE: self.app.cancel_lxmf_sync() max_messages_group = [] r_mall = urwid.RadioButton(max_messages_group, "Download all", state=True) r_mlim = urwid.RadioButton(max_messages_group, "Limit to", state=False) ie_lim = urwid.IntEdit("", 5) rbs = urwid.GridFlow([r_mlim, ie_lim], 12, 1, 0, align=urwid.LEFT) def sync_now(sender): limit = None if r_mlim.get_state(): limit = ie_lim.value() self.app.request_lxmf_sync(limit) self.update_sync_dialog() def cancel_sync(sender): self.app.cancel_lxmf_sync() self.update_sync_dialog() cancel_button = urwid.Button("Close", on_press=dismiss_dialog) sync_progress = SyncProgressBar("progress_empty" , "progress_full", current=self.app.get_sync_progress(), done=1.0, satt=None) real_sync_button = urwid.Button("Sync Now", on_press=sync_now) hidden_sync_button = urwid.Button("Cancel Sync", on_press=cancel_sync) if self.app.get_sync_status() == "Idle" or self.app.message_router.propagation_transfer_state >= LXMF.LXMRouter.PR_COMPLETE: sync_button = real_sync_button else: sync_button = hidden_sync_button button_columns = urwid.Columns([ (urwid.WEIGHT, 0.45, sync_button), (urwid.WEIGHT, 0.1, urwid.Text("")), (urwid.WEIGHT, 0.45, cancel_button), ]) real_sync_button.bc = button_columns pn_ident = None if self.app.get_default_propagation_node() != None: pn_hash = self.app.get_default_propagation_node() pn_ident = RNS.Identity.recall(pn_hash) if pn_ident == None: RNS.log("Propagation node identity is unknown, requesting from network...", RNS.LOG_DEBUG) RNS.Transport.request_path(pn_hash) if pn_ident != None: node_hash = RNS.Destination.hash_from_name_and_identity("nomadnetwork.node", pn_ident) pn_entry = self.app.directory.find(node_hash) pn_display_str = " " if pn_entry != None: pn_display_str += " "+str(pn_entry.display_name) else: pn_display_str += " "+RNS.prettyhexrep(pn_hash) dialog = DialogLineBox( urwid.Pile([ urwid.Text(""+g["node"]+pn_display_str, align=urwid.CENTER), urwid.Divider(g["divider1"]), sync_progress, urwid.Divider(g["divider1"]), r_mall, rbs, urwid.Text(""), button_columns ]), title="Message Sync" ) else: button_columns = urwid.Columns([ (urwid.WEIGHT, 0.45, urwid.Text("" )), (urwid.WEIGHT, 0.1, urwid.Text("")), (urwid.WEIGHT, 0.45, cancel_button), ]) dialog = DialogLineBox( urwid.Pile([ urwid.Text(""), urwid.Text("No trusted nodes found, cannot sync!\n", align=urwid.CENTER), urwid.Text( "To synchronise messages from the network, " "one or more nodes must be marked as trusted in the Known Nodes list, " "or a node must manually be selected as the default propagation node. " "Nomad Network will then automatically sync from the nearest trusted node, " "or the manually selected one.", align=urwid.LEFT, ), urwid.Text(""), button_columns ]), title="Message Sync" ) dialog.delegate = self dialog.sync_progress = sync_progress dialog.cancel_button = cancel_button dialog.real_sync_button = real_sync_button dialog.hidden_sync_button = hidden_sync_button dialog.bc = button_columns self.sync_dialog = dialog bottom = self.listbox overlay = urwid.Overlay( dialog, bottom, align=urwid.CENTER, width=urwid.RELATIVE_100, valign=urwid.MIDDLE, height=urwid.PACK, left=2, right=2, ) # options = self.columns_widget.options(urwid.WEIGHT, ConversationsDisplay.list_width) options = self.columns_widget.options(urwid.GIVEN, ConversationsDisplay.given_list_width) self.columns_widget.contents[0] = (overlay, options) def update_sync_dialog(self, loop = None, sender = None): if self.dialog_open and self.sync_dialog != None: self.sync_dialog.sync_progress.set_completion(self.app.get_sync_progress()) if self.app.get_sync_status() == "Idle" or self.app.message_router.propagation_transfer_state >= LXMF.LXMRouter.PR_COMPLETE: self.sync_dialog.bc.contents[0] = (self.sync_dialog.real_sync_button, self.sync_dialog.bc.options(urwid.WEIGHT, 0.45)) else: self.sync_dialog.bc.contents[0] = (self.sync_dialog.hidden_sync_button, self.sync_dialog.bc.options(urwid.WEIGHT, 0.45)) self.app.ui.loop.set_alarm_in(0.2, self.update_sync_dialog) def conversation_list_selection(self, arg1, arg2): pass def update_conversation_list(self): selected_hash = None selected_item = self.ilb.get_selected_item() if selected_item is not None: if hasattr(selected_item, "source_hash"): selected_hash = selected_item.source_hash self.update_listbox() options = self.columns_widget.options(urwid.GIVEN, ConversationsDisplay.given_list_width) if not (self.dialog_open and self.sync_dialog != None): self.columns_widget.contents[0] = (self.listbox, options) else: bottom = self.listbox overlay = urwid.Overlay( self.sync_dialog, bottom, align=urwid.CENTER, width=urwid.RELATIVE_100, valign=urwid.MIDDLE, height=urwid.PACK, left=2, right=2, ) self.columns_widget.contents[0] = (overlay, options) if selected_hash is not None: for idx, widget in enumerate(self.list_widgets): if widget.source_hash == selected_hash: self.ilb.select_item(idx) break nomadnet.NomadNetworkApp.get_shared_instance().ui.loop.draw_screen() if self.app.ui.main_display.sub_displays.active_display == self.app.ui.main_display.sub_displays.conversations_display: if self.currently_displayed_conversation != None: if self.app.conversation_is_unread(self.currently_displayed_conversation): self.app.mark_conversation_read(self.currently_displayed_conversation) try: if os.path.isfile(self.app.conversationpath + "/" + self.currently_displayed_conversation + "/unread"): os.unlink(self.app.conversationpath + "/" + self.currently_displayed_conversation + "/unread") except Exception as e: raise e def display_conversation(self, sender=None, source_hash=None): if self.currently_displayed_conversation != None: if self.app.conversation_is_unread(self.currently_displayed_conversation): self.app.mark_conversation_read(self.currently_displayed_conversation) self.currently_displayed_conversation = source_hash # options = self.widget.options(urwid.WEIGHT, 1-ConversationsDisplay.list_width) options = self.widget.options(urwid.WEIGHT, 1) self.widget.contents[1] = (self.make_conversation_widget(source_hash), options) if source_hash == None: self.widget.focus_position = 0 else: if self.app.conversation_is_unread(source_hash): self.app.mark_conversation_read(source_hash) self.update_conversation_list() self.widget.focus_position = 1 conversation_position = None index = 0 for widget in self.list_widgets: if widget.source_hash == source_hash: conversation_position = index index += 1 if conversation_position != None: self.ilb.select_item(conversation_position) def make_conversation_widget(self, source_hash): if source_hash in ConversationsDisplay.cached_conversation_widgets: conversation_widget = ConversationsDisplay.cached_conversation_widgets[source_hash] if source_hash != None: conversation_widget.update_message_widgets(replace=True) conversation_widget.check_editor_allowed() return conversation_widget else: widget = ConversationWidget(source_hash) widget.delegate = self ConversationsDisplay.cached_conversation_widgets[source_hash] = widget widget.check_editor_allowed() return widget def close_conversation_by_hash(self, conversation_hash): if conversation_hash in ConversationsDisplay.cached_conversation_widgets: ConversationsDisplay.cached_conversation_widgets.pop(conversation_hash) if self.currently_displayed_conversation == conversation_hash: self.display_conversation(sender=None, source_hash=None) def close_conversation(self, conversation): if conversation.source_hash in ConversationsDisplay.cached_conversation_widgets: ConversationsDisplay.cached_conversation_widgets.pop(conversation.source_hash) if self.currently_displayed_conversation == conversation.source_hash: self.display_conversation(sender=None, source_hash=None) def conversation_list_widget(self, conversation): trust_level = conversation[2] display_name = conversation[1] source_hash = conversation[0] unread = conversation[4] last_activity = conversation[5] g = self.app.ui.glyphs if trust_level == DirectoryEntry.UNTRUSTED: symbol = g["cross"] style = "list_untrusted" focus_style = "list_focus_untrusted" elif trust_level == DirectoryEntry.UNKNOWN: symbol = "?" style = "list_unknown" focus_style = "list_focus" elif trust_level == DirectoryEntry.TRUSTED: symbol = g["check"] style = "list_trusted" focus_style = "list_focus_trusted" elif trust_level == DirectoryEntry.WARNING: symbol = g["warning"] style = "list_warning" focus_style = "list_focus" else: symbol = g["warning"] style = "list_untrusted" focus_style = "list_focus_untrusted" display_text = symbol if display_name != None and display_name != "": display_text += " "+display_name if trust_level != DirectoryEntry.TRUSTED: display_text += " <"+source_hash+">" if trust_level != DirectoryEntry.UNTRUSTED: if unread: if source_hash != self.currently_displayed_conversation: if unread > 1: display_text += " "+g["unread"]+" ("+str(unread)+")" else: display_text += " "+g["unread"] if last_activity > 0: display_text += "\n "+relative_time(last_activity) widget = ListEntry(display_text) urwid.connect_signal(widget, "click", self.display_conversation, conversation[0]) display_widget = urwid.AttrMap(widget, style, focus_style) display_widget.source_hash = source_hash display_widget.display_name = display_name return display_widget def shortcuts(self): focus_path = self.widget.get_focus_path() if focus_path[0] == 0: return self.list_shortcuts elif focus_path[0] == 1: return self.editor_shortcuts else: return self.list_shortcuts class ListEntry(urwid.Text): _selectable = True signals = ["click"] def keypress(self, size, key): """ Send 'click' signal on 'activate' command. """ if self._command_map[key] != urwid.ACTIVATE: return key self._emit('click') def mouse_event(self, size, event, button, x, y, focus): """ Send 'click' signal on button 1 press. """ if button != 1 or not urwid.util.is_mouse_press(event): return False self._emit('click') return True class MessageEdit(urwid.Edit): def keypress(self, size, key): if key == "ctrl d": self.delegate.send_message() elif key == "ctrl p": self.delegate.paper_message() elif key == "ctrl a": self.delegate.attach_file() elif key == "ctrl s": self.delegate.save_focused_attachments() elif key == "ctrl k": self.delegate.clear_editor() elif key == "up": y = self.get_cursor_coords(size)[1] if y == 0: if self.delegate.full_editor_active and self.name == "title_editor": self.delegate.frame.focus_position = "body" elif not self.delegate.full_editor_active and self.name == "content_editor": self.delegate.frame.focus_position = "body" else: return super(MessageEdit, self).keypress(size, key) else: return super(MessageEdit, self).keypress(size, key) else: return super(MessageEdit, self).keypress(size, key) class ConversationFrame(urwid.Frame): def keypress(self, size, key): if self.focus_position == "body": if getattr(self.delegate, "dialog_active", False) or getattr(self.delegate, "dialog_open", False): return super(ConversationFrame, self).keypress(size, key) elif key == "up" and self.delegate.messagelist.top_is_visible: nomadnet.NomadNetworkApp.get_shared_instance().ui.main_display.frame.focus_position = "header" elif key == "down" and self.delegate.messagelist.bottom_is_visible: self.focus_position = "footer" else: return super(ConversationFrame, self).keypress(size, key) elif key == "ctrl k": self.delegate.clear_editor() else: return super(ConversationFrame, self).keypress(size, key) class ConversationWidget(urwid.WidgetWrap): def __init__(self, source_hash): self.app = nomadnet.NomadNetworkApp.get_shared_instance() g = self.app.ui.glyphs if source_hash == None: self.frame = None display_widget = urwid.LineBox(urwid.Filler(urwid.Text("\n No conversation selected"), "top")) super().__init__(display_widget) else: if source_hash in ConversationsDisplay.cached_conversation_widgets: return ConversationsDisplay.cached_conversation_widgets[source_hash] else: self.source_hash = source_hash self.conversation = nomadnet.Conversation(source_hash, nomadnet.NomadNetworkApp.get_shared_instance()) self.message_widgets = [] self.sort_by_timestamp = False self.updating_message_widgets = False self.pending_attachments = [] self.dialog_active = False self.update_message_widgets() self.conversation.register_changed_callback(self._on_conversation_changed_from_callback) #title_editor = MessageEdit(caption="\u270E", edit_text="", multiline=False) title_editor = MessageEdit(caption="", edit_text="", multiline=False) title_editor.delegate = self title_editor.name = "title_editor" #msg_editor = MessageEdit(caption="\u270E", edit_text="", multiline=True) msg_editor = MessageEdit(caption="", edit_text="", multiline=True) msg_editor.delegate = self msg_editor.name = "content_editor" self.peer_info_widget = urwid.AttrMap(urwid.Text(""), "msg_header_sent") self._update_peer_info() header_widgets = [self.peer_info_widget] if self.conversation.trust_level == DirectoryEntry.UNTRUSTED: header_widgets.append(urwid.AttrMap( urwid.Padding( urwid.Text(g["warning"]+" Warning: Conversation with untrusted peer "+g["warning"], align=urwid.CENTER)), "msg_warning_untrusted", )) header = urwid.Pile(header_widgets) self.minimal_editor = urwid.AttrMap(msg_editor, "msg_editor") self.minimal_editor.name = "minimal_editor" title_columns = urwid.Columns([ (8, urwid.Text("Title")), urwid.AttrMap(title_editor, "msg_editor"), ]) content_columns = urwid.Columns([ (8, urwid.Text("Content")), urwid.AttrMap(msg_editor, "msg_editor") ]) self.full_editor = urwid.Pile([ title_columns, content_columns ]) self.full_editor.name = "full_editor" self.content_editor = msg_editor self.title_editor = title_editor self.full_editor_active = False self.frame = ConversationFrame( self.messagelist, header=header, footer=self.minimal_editor, focus_part="footer" ) self.frame.delegate = self self.display_widget = urwid.LineBox( self.frame ) super().__init__(self.display_widget) def _update_peer_info(self): def san(name): if self.app.config["textui"]["sanitize_names"]: return sanitize_name(name) else: return strip_modifiers(name) g = self.app.ui.glyphs source_hash_bytes = bytes.fromhex(self.source_hash) display_name = self.app.directory.display_name(source_hash_bytes) app_data = None if display_name is None or self.app.message_router.get_outbound_stamp_cost(source_hash_bytes) is None: app_data = RNS.Identity.recall_app_data(source_hash_bytes) if display_name is None: if app_data: display_name = san(LXMF.display_name_from_app_data(app_data)) if display_name is None: display_name = RNS.prettyhexrep(source_hash_bytes) stamp_cost = self.app.message_router.get_outbound_stamp_cost(source_hash_bytes) if stamp_cost is None and app_data: stamp_cost = LXMF.stamp_cost_from_app_data(app_data) hops = RNS.Transport.hops_to(source_hash_bytes) if hops >= RNS.Transport.PATHFINDER_M: hops_str = "unknown" else: hops_str = str(hops)+" hop" + ("s" if hops != 1 else "") right_parts = [] if stamp_cost is not None: right_parts.append("Stamp: "+str(stamp_cost)) right_parts.append(g["speed"]+hops_str) left = " "+display_name right = " ".join(right_parts)+" " self.peer_info_widget.original_widget.set_text(left+" | "+right) def clear_history_dialog(self): def dismiss_dialog(sender): self.dialog_open = False self.conversation_changed(None) def confirmed(sender): self.dialog_open = False self.conversation.clear_history() self.conversation_changed(None) dialog = DialogLineBox( urwid.Pile([ urwid.Text("Clear conversation history\n", align=urwid.CENTER), urwid.Columns([ (urwid.WEIGHT, 0.45, urwid.Button("Yes", on_press=confirmed)), (urwid.WEIGHT, 0.1, urwid.Text("")), (urwid.WEIGHT, 0.45, urwid.Button("No", on_press=dismiss_dialog)), ]) ]), title="?" ) dialog.delegate = self bottom = self.messagelist overlay = urwid.Overlay( dialog, bottom, align=urwid.CENTER, width=34, valign=urwid.MIDDLE, height=urwid.PACK, left=2, right=2, ) self.frame.contents["body"] = (overlay, self.frame.options()) self.frame.focus_position = "body" def _build_footer(self): g = self.app.ui.glyphs if self.full_editor_active: editor = self.full_editor else: editor = self.minimal_editor if self.pending_attachments: attachment_texts = [] for path in self.pending_attachments: attachment_texts.append(os.path.basename(path)) indicator = urwid.AttrMap( urwid.Text(g["file"]+" "+str(len(self.pending_attachments))+" file(s): "+", ".join(attachment_texts)), "msg_header_sent", ) return urwid.Pile([indicator, editor]) else: return editor def toggle_editor(self): if self.full_editor_active: self.full_editor_active = False else: self.full_editor_active = True self.frame.contents["footer"] = (self._build_footer(), None) def check_editor_allowed(self): g = self.app.ui.glyphs if self.frame: allowed = nomadnet.NomadNetworkApp.get_shared_instance().directory.is_known(bytes.fromhex(self.source_hash)) if allowed: self.frame.contents["footer"] = (self._build_footer(), None) else: warning = urwid.AttrMap( urwid.Padding(urwid.Text( "\n"+g["info"]+"\n\nYou cannot currently message this peer, since its identity keys are not known. " "The keys have been requested from the network and should arrive shortly, if available. " "Close this conversation and reopen it to try again.\n\n" "To query the network manually, select this conversation in the conversation list, " "press Ctrl-E, and use the query button.\n", align=urwid.CENTER, )), "msg_header_caution", ) self.frame.contents["footer"] = (warning, None) def toggle_focus_area(self): name = "" try: name = self.frame.get_focus_widgets()[0].name except Exception as e: pass if name == "messagelist": self.frame.focus_position = "footer" elif name == "minimal_editor" or name == "full_editor": self.frame.focus_position = "body" def keypress(self, size, key): if key == "tab": self.toggle_focus_area() elif key == "ctrl w": self.close() elif key == "ctrl u": self.conversation.purge_failed() self.conversation_changed(None) elif key == "ctrl t": self.toggle_editor() elif key == "ctrl x": self.clear_history_dialog() elif key == "ctrl g": nomadnet.NomadNetworkApp.get_shared_instance().ui.main_display.sub_displays.conversations_display.toggle_fullscreen() elif key == "ctrl o": self.sort_by_timestamp ^= True self.conversation_changed(None) elif key == "ctrl a": self.attach_file() elif key == "ctrl s": self.save_focused_attachments() else: return super(ConversationWidget, self).keypress(size, key) def _on_conversation_changed_from_callback(self, conversation): delegate = getattr(self, "delegate", None) if delegate is not None and hasattr(delegate, "_wake"): delegate._wake(lambda: self.conversation_changed(conversation)) else: self.conversation_changed(conversation) def conversation_changed(self, conversation): if hasattr(self, "peer_info_widget"): self._update_peer_info() self.update_message_widgets(replace = True) def update_message_widgets(self, replace = False): while self.updating_message_widgets: time.sleep(0.5) self.updating_message_widgets = True self.message_widgets = [] added_hashes = [] needs_index = [] for message in self.conversation.messages: message_hash = message.get_hash() if not message_hash in added_hashes: added_hashes.append(message_hash) was_loaded = message.loaded message_widget = LXMessageWidget(message) self.message_widgets.append(message_widget) if not was_loaded and message.loaded: needs_index.append(message) message.unload() if needs_index: try: ConversationMessage.write_index( self.conversation.messages_path, needs_index) except Exception: pass if self.sort_by_timestamp: self.message_widgets.sort(key=lambda m: m.timestamp, reverse=False) else: self.message_widgets.sort(key=lambda m: m.sort_timestamp, reverse=False) from nomadnet.vendor.additional_urwid_widgets import IndicativeListBox self.messagelist = IndicativeListBox(self.message_widgets, position = len(self.message_widgets)-1) self.messagelist.name = "messagelist" if replace: self.frame.contents["body"] = (self.messagelist, None) nomadnet.NomadNetworkApp.get_shared_instance().ui.loop.draw_screen() self.updating_message_widgets = False def clear_editor(self): self.content_editor.set_edit_text("") self.title_editor.set_edit_text("") self.pending_attachments = [] self.frame.contents["footer"] = (self._build_footer(), None) def _collect_attachment_refs(self): g = self.app.ui.glyphs refs = [] sorted_messages = sorted(self.conversation.messages, key=lambda m: m.sort_timestamp, reverse=True) for conv_message in sorted_messages: if not conv_message.has_attachments(): continue cached_names = conv_message._cached_attachment_names or [] att_file_idx = 0 for atype, aname, *arest in cached_names: asize = arest[0] if arest else 0 glyph = g["file"] if atype == "file" else g[atype] label = glyph+" "+aname if asize > 0: label += " ("+_format_size(asize)+")" if atype == "file": refs.append((label, aname, conv_message, "file", att_file_idx)) att_file_idx += 1 else: refs.append((label, aname, conv_message, atype, 0)) return refs def save_focused_attachments(self): g = self.app.ui.glyphs self.dialog_active = True try: attachment_items = self._collect_attachment_refs() except Exception as e: RNS.log("Error collecting attachments: "+str(e), RNS.LOG_ERROR) attachment_items = [] save_dir = self.app.attachment_save_path if self.app.attachment_save_path else self.app.downloads_path def dismiss_dialog(sender): self.dialog_active = False self.conversation_changed(None) if not attachment_items: dialog = DialogLineBox( urwid.Pile([ urwid.Text("No attachments in this conversation.\n"), urwid.Columns([ (urwid.WEIGHT, 0.6, urwid.Text("")), (urwid.WEIGHT, 0.4, urwid.Button("OK", on_press=dismiss_dialog)), ]) ]), title="Attachments" ) dialog.delegate = self bottom = self.messagelist overlay = urwid.Overlay(dialog, bottom, align=urwid.CENTER, width=45, valign=urwid.MIDDLE, height=urwid.PACK, left=2, right=2) self.frame.contents["body"] = (overlay, self.frame.options()) self.frame.focus_position = "body" return checkboxes = [] for label, filename, conv_msg, field_type, field_index in attachment_items: cb = urwid.CheckBox(label, state=False) cb._attachment_filename = filename cb._conv_message = conv_msg cb._field_type = field_type cb._field_index = field_index checkboxes.append(cb) status_text = urwid.Text("") def do_save(sender): saved = [] errors = [] for cb in checkboxes: if cb.get_state(): try: src_path = cb._conv_message.get_attachment_file_path(cb._field_type, cb._field_index) if src_path and os.path.isfile(src_path): path = _copy_attachment_to_dest(cb._attachment_filename, src_path) saved.append(path) except Exception as e: errors.append(str(e)) if saved: lines = [g["check"]+" Copied "+str(len(saved))+" file(s) to "+save_dir+":"] for p in saved: lines.append(" "+os.path.basename(p)) if errors: lines.append(g["cross"]+" "+str(len(errors))+" failed") status_text.set_text("\n".join(lines)) elif errors: status_text.set_text(g["cross"]+" Failed: "+errors[0]) else: status_text.set_text("No files selected") dialog_widgets = list(checkboxes) dialog_widgets.append(urwid.Divider(g["divider1"])) dialog_widgets.append(urwid.Text("Copy to: "+save_dir)) dialog_widgets.append(status_text) dialog_widgets.append(urwid.Text("")) dialog_widgets.append(urwid.Columns([ (urwid.WEIGHT, 0.45, urwid.Button("Copy to Downloads", on_press=do_save)), (urwid.WEIGHT, 0.1, urwid.Text("")), (urwid.WEIGHT, 0.45, urwid.Button("Close", on_press=dismiss_dialog)), ])) dialog = DialogLineBox(urwid.ListBox(urwid.SimpleFocusListWalker(dialog_widgets)), title="Attachments") dialog.delegate = self bottom = self.messagelist overlay = urwid.Overlay(dialog, bottom, align=urwid.CENTER, width=("relative", 80), valign=urwid.MIDDLE, height=("relative", 80), left=2, right=2) self.frame.contents["body"] = (overlay, self.frame.options()) self.frame.focus_position = "body" def send_message(self): content = self.content_editor.get_edit_text() title = self.title_editor.get_edit_text() if not content == "": fields = None if self.pending_attachments: file_attachments = [] for file_path in self.pending_attachments: try: with open(file_path, "rb") as af: file_data = af.read() file_name = os.path.basename(file_path) file_attachments.append([file_name, file_data]) except Exception as e: RNS.log("Error reading attachment "+str(file_path)+": "+str(e), RNS.LOG_ERROR) if file_attachments: fields = {LXMF.FIELD_FILE_ATTACHMENTS: file_attachments} if self.conversation.send(content, title, fields=fields): self.clear_editor() def attach_file(self): self.dialog_active = True browser = FileBrowserDialog(self) bottom = self.messagelist overlay = urwid.Overlay(browser, bottom, align=urwid.CENTER, width=("relative", 90), valign=urwid.MIDDLE, height=("relative", 80), left=2, right=2) self.frame.contents["body"] = (overlay, self.frame.options()) self.frame.focus_position = "body" def file_browser_closed(self): self.dialog_active = False self.frame.contents["footer"] = (self._build_footer(), None) self.conversation_changed(None) def paper_message_saved(self, path): g = self.app.ui.glyphs def dismiss_dialog(sender): self.dialog_open = False self.conversation_changed(None) dialog = DialogLineBox( urwid.Pile([ urwid.Text("The paper message was saved to:\n\n"+str(path)+"\n", align=urwid.CENTER), urwid.Columns([ (urwid.WEIGHT, 0.6, urwid.Text("")), (urwid.WEIGHT, 0.4, urwid.Button("OK", on_press=dismiss_dialog)), ]) ]), title=g["papermsg"].replace(" ", "") ) dialog.delegate = self bottom = self.messagelist overlay = urwid.Overlay(dialog, bottom, align=urwid.CENTER, width=60, valign=urwid.MIDDLE, height=urwid.PACK, left=2, right=2) self.frame.contents["body"] = (overlay, self.frame.options()) self.frame.focus_position = "body" def print_paper_message_qr(self): content = self.content_editor.get_edit_text() title = self.title_editor.get_edit_text() if not content == "": if self.conversation.paper_output(content, title): self.clear_editor() else: self.paper_message_failed() def save_paper_message_qr(self): content = self.content_editor.get_edit_text() title = self.title_editor.get_edit_text() if not content == "": output_result = self.conversation.paper_output(content, title, mode="save_qr") if output_result != False: self.clear_editor() self.paper_message_saved(output_result) else: self.paper_message_failed() def save_paper_message_uri(self): content = self.content_editor.get_edit_text() title = self.title_editor.get_edit_text() if not content == "": output_result = self.conversation.paper_output(content, title, mode="save_uri") if output_result != False: self.clear_editor() self.paper_message_saved(output_result) else: self.paper_message_failed() def paper_message(self): def dismiss_dialog(sender): self.dialog_open = False self.conversation_changed(None) def print_qr(sender): dismiss_dialog(self) self.print_paper_message_qr() def save_qr(sender): dismiss_dialog(self) self.save_paper_message_qr() def save_uri(sender): dismiss_dialog(self) self.save_paper_message_uri() dialog = DialogLineBox( urwid.Pile([ urwid.Text( "Select the desired paper message output method.\nSaved files will be written to:\n\n"+str(self.app.downloads_path)+"\n", align=urwid.CENTER, ), urwid.Columns([ (urwid.WEIGHT, 0.5, urwid.Button("Print QR", on_press=print_qr)), (urwid.WEIGHT, 0.1, urwid.Text("")), (urwid.WEIGHT, 0.5, urwid.Button("Save QR", on_press=save_qr)), (urwid.WEIGHT, 0.1, urwid.Text("")), (urwid.WEIGHT, 0.5, urwid.Button("Save URI", on_press=save_uri)), (urwid.WEIGHT, 0.1, urwid.Text("")), (urwid.WEIGHT, 0.5, urwid.Button("Cancel", on_press=dismiss_dialog)) ]) ]), title="Create Paper Message" ) dialog.delegate = self bottom = self.messagelist overlay = urwid.Overlay(dialog, bottom, align=urwid.CENTER, width=60, valign=urwid.MIDDLE, height=urwid.PACK, left=2, right=2) self.frame.contents["body"] = (overlay, self.frame.options()) self.frame.focus_position = "body" def paper_message_failed(self): def dismiss_dialog(sender): self.dialog_open = False self.conversation_changed(None) dialog = DialogLineBox( urwid.Pile([ urwid.Text( "Could not output paper message,\ncheck your settings. See the log\nfile for any error messages.\n", align=urwid.CENTER, ), urwid.Columns([ (urwid.WEIGHT, 0.6, urwid.Text("")), (urwid.WEIGHT, 0.4, urwid.Button("OK", on_press=dismiss_dialog)), ]) ]), title="!" ) dialog.delegate = self bottom = self.messagelist overlay = urwid.Overlay(dialog, bottom, align=urwid.CENTER, width=34, valign=urwid.MIDDLE, height=urwid.PACK, left=2, right=2) self.frame.contents["body"] = (overlay, self.frame.options()) self.frame.focus_position = "body" def close(self): self.delegate.close_conversation(self) class LXMessageWidget(urwid.WidgetWrap): def __init__(self, message): app = nomadnet.NomadNetworkApp.get_shared_instance() g = app.ui.glyphs self.timestamp = message.get_timestamp() self.sort_timestamp = message.sort_timestamp self.transfer_done = False self._live_lxm = None msg_hash = message.get_hash() msg_state = message.get_state() msg_source_hash = message._cached_source_hash msg_method = message._cached_method time_format = app.time_format message_time = datetime.fromtimestamp(self.timestamp) encryption_string = "" if message.get_transport_encrypted(): encryption_string = " "+g["encrypted"] else: encryption_string = " "+g["plaintext"] title_string = relative_time(self.timestamp)+" | "+message_time.strftime(time_format)+encryption_string is_outbound = False if msg_source_hash is None: header_style = "msg_header_failed" title_string = g["warning"]+" "+title_string elif app.lxmf_destination.hash == msg_source_hash: is_outbound = True if msg_state == LXMF.LXMessage.DELIVERED: header_style = "msg_header_delivered" title_string = g["check"]+" "+g["arrow_r"]+" "+title_string elif msg_state == LXMF.LXMessage.FAILED: header_style = "msg_header_failed" title_string = g["cross"]+" "+g["arrow_r"]+" "+title_string elif msg_state == LXMF.LXMessage.REJECTED: header_style = "msg_header_failed" title_string = g["cross"]+" "+g["arrow_r"]+" Rejected "+title_string elif msg_method == LXMF.LXMessage.PROPAGATED and msg_state == LXMF.LXMessage.SENT: header_style = "msg_header_propagated" title_string = g["sent"]+" "+g["arrow_r"]+" "+title_string elif msg_method == LXMF.LXMessage.PAPER and msg_state == LXMF.LXMessage.PAPER: header_style = "msg_header_propagated" title_string = g["papermsg"]+" "+g["arrow_r"]+" "+title_string elif msg_state == LXMF.LXMessage.SENT: header_style = "msg_header_sent" title_string = g["sent"]+" "+g["arrow_r"]+" "+title_string else: header_style = "msg_header_sent" title_string = g["arrow_r"]+" "+title_string else: if message.signature_validated(): header_style = "msg_header_ok" title_string = g["check"]+" "+g["arrow_l"]+" "+title_string else: header_style = "msg_header_caution" title_string = g["warning"]+" "+g["arrow_l"]+" "+message.get_signature_description() + "\n " + title_string if message.get_title() != "": title_string += " | " + message.get_title() has_attachments = message.has_attachments() cached_names = message._cached_attachment_names or [] if has_attachments and cached_names: attachment_strings = [] for atype, aname, *arest in cached_names: attachment_strings.append(g[atype if atype != "file" else "file"]+" "+aname) title_string += " | " + " ".join(attachment_strings) title = urwid.AttrMap(urwid.Text(title_string), header_style) self.progress_widget = urwid.Text("") self.progress_attr = urwid.AttrMap(self.progress_widget, "progress_full") content_text = message.get_content() content_lines = content_text.split("\n") indented = "\n".join(" "+line for line in content_lines) pile_widgets = [title] if is_outbound and msg_state is not None and msg_state < LXMF.LXMessage.SENT and msg_hash is not None: try: for pending in app.message_router.pending_outbound: if pending.hash == msg_hash: if pending.representation == LXMF.LXMessage.RESOURCE: self._live_lxm = pending break except Exception: pass if self._live_lxm is not None: pct = int(self._live_lxm.progress * 100) bar_width = 20 filled = int(bar_width * self._live_lxm.progress) if app.ui.colormode >= 256: bar = "\u2588" * filled + "\u2591" * (bar_width - filled) else: bar = "#" * filled + "-" * (bar_width - filled) self.progress_widget.set_text(" ["+bar+"] "+str(pct)+"%") pile_widgets.append(self.progress_attr) self._start_progress_poll() pile_widgets.append(urwid.Text(indented)) if has_attachments and cached_names: att_file_idx = 0 for atype, aname, *arest in cached_names: glyph = g["file"] if atype == "file" else g[atype] asize = arest[0] if arest else 0 label = " "+glyph+" "+aname if asize > 0: label += " ("+_format_size(asize)+")" if atype == "file": pile_widgets.append(ClickableAttachment(label, aname, message, "file", att_file_idx)) att_file_idx += 1 else: pile_widgets.append(ClickableAttachment(label, aname, message, atype)) pile_widgets.append(urwid.Text("")) super().__init__(urwid.Pile(pile_widgets)) def _start_progress_poll(self): try: loop = nomadnet.NomadNetworkApp.get_shared_instance().ui.loop if loop: loop.set_alarm_in(0.3, self._poll_progress) except Exception: pass def _poll_progress(self, loop=None, user_data=None): if self.transfer_done: return if self._live_lxm is None: self.transfer_done = True return app = nomadnet.NomadNetworkApp.get_shared_instance() g = app.ui.glyphs progress = self._live_lxm.progress state = self._live_lxm.state pct = int(progress * 100) if state == LXMF.LXMessage.FAILED: self.progress_widget.set_text(" "+g["cross"]+" Transfer failed") self.transfer_done = True self._live_lxm = None elif state == LXMF.LXMessage.REJECTED: self.progress_widget.set_text(" "+g["cross"]+" Rejected: too large or not accepted") self.transfer_done = True self._live_lxm = None elif state >= LXMF.LXMessage.SENT: self.progress_widget.set_text("") self.transfer_done = True self._live_lxm = None else: bar_width = 20 filled = int(bar_width * progress) if app.ui.colormode >= 256: bar = "\u2588" * filled + "\u2591" * (bar_width - filled) else: bar = "#" * filled + "-" * (bar_width - filled) self.progress_widget.set_text(" ["+bar+"] "+str(pct)+"%") if not self.transfer_done: try: ui_loop = app.ui.loop if ui_loop: ui_loop.set_alarm_in(0.3, self._poll_progress) ui_loop.draw_screen() except Exception: pass class ClickableAttachment(urwid.Text): def __init__(self, label, filename, conv_message, field_type, field_index=0): self.filename = filename self.conv_message = conv_message self.field_type = field_type self.field_index = field_index self.saved = False super().__init__(label) def mouse_event(self, size, event, button, x, y, focus): if button == 1 and urwid.util.is_mouse_press(event): self._save() return True return False def _save(self): if self.saved: return app = nomadnet.NomadNetworkApp.get_shared_instance() g = app.ui.glyphs try: src_path = self.conv_message.get_attachment_file_path(self.field_type, self.field_index) if src_path and os.path.isfile(src_path): save_path = _copy_attachment_to_dest(self.filename, src_path) else: if self.field_type == "file": attachments = self.conv_message.get_file_attachments() if self.field_index < len(attachments): att = attachments[self.field_index] if isinstance(att, list) and len(att) >= 2: data = att[1] if isinstance(att[1], bytes) else b"" else: data = b"" else: data = b"" elif self.field_type == "image": data = self.conv_message.get_image() data = data if isinstance(data, bytes) else b"" elif self.field_type == "audio": data = self.conv_message.get_audio() data = data if isinstance(data, bytes) else b"" else: data = b"" self.conv_message.unload() if not data: return save_path = _save_attachment_to_disk(self.filename, data) self.saved = True self.set_text(" "+g["check"]+" Copied to: "+save_path) except Exception as e: RNS.log("Error saving attachment: "+str(e), RNS.LOG_ERROR) self.set_text(" "+g["cross"]+" Save failed: "+str(e)) def _resolve_attachment_save_path(filename): app = nomadnet.NomadNetworkApp.get_shared_instance() save_dir = app.attachment_save_path if app.attachment_save_path else app.downloads_path if not os.path.isdir(save_dir): os.makedirs(save_dir) safe_name = ConversationMessage.safe_attachment_name(filename) base_dir = os.path.realpath(save_dir) + os.sep candidate = os.path.realpath(os.path.join(save_dir, safe_name)) if not (candidate + os.sep).startswith(base_dir): raise OSError(13, os.strerror(13)) counter = 0 base, ext = os.path.splitext(safe_name) while os.path.isfile(candidate): counter += 1 candidate = os.path.realpath(os.path.join(save_dir, base+"_"+str(counter)+ext)) if not (candidate + os.sep).startswith(base_dir): raise OSError(13, os.strerror(13)) return candidate def _copy_attachment_to_dest(filename, src_path): save_path = _resolve_attachment_save_path(filename) shutil.copy2(src_path, save_path) return save_path def _save_attachment_to_disk(filename, data): save_path = _resolve_attachment_save_path(filename) with open(save_path, "wb") as f: f.write(data) return save_path class FileBrowserEntry(urwid.WidgetWrap): signals = ["click"] def __init__(self, name, full_path, is_dir=False, is_parent=False, selected=False): self.full_path = full_path self.name = name self.is_dir = is_dir self.is_parent = is_parent self.selected = selected g = nomadnet.NomadNetworkApp.get_shared_instance().ui.glyphs if is_parent: display = g["arrow_l"]+" .." elif is_dir: display = g["arrow_r"]+" "+name+"/" elif selected: display = g["check"]+" "+name else: display = " "+name self.text_widget = urwid.SelectableIcon(display, 0) if is_dir or is_parent: style = "list_trusted" focus_style = "list_focus" elif selected: style = "list_trusted" focus_style = "list_focus_trusted" else: style = "list_unknown" focus_style = "list_focus" display_widget = urwid.AttrMap(self.text_widget, style, focus_style) super().__init__(display_widget) def keypress(self, size, key): if key == "enter": self._emit("click") else: return key def mouse_event(self, size, event, button, x, y, focus): if button == 1 and urwid.util.is_mouse_press(event): self._emit("click") return True return False class FileBrowserDialog(urwid.WidgetWrap): def __init__(self, delegate): self.delegate = delegate app = nomadnet.NomadNetworkApp.get_shared_instance() self.g = app.ui.glyphs self.current_path = os.path.expanduser("~") self.path_label = urwid.Text("") self.status_label = urwid.Text("") self.file_walker = urwid.SimpleFocusListWalker([]) self.file_listbox = urwid.ListBox(self.file_walker) self.button_columns = urwid.Columns([ (urwid.WEIGHT, 0.45, urwid.Button("Done", on_press=self._dismiss)), (urwid.WEIGHT, 0.1, urwid.Text("")), (urwid.WEIGHT, 0.45, urwid.Button("Cancel", on_press=self._cancel)), ]) header_pile = urwid.Pile([ self.path_label, self.status_label, urwid.Divider(self.g["divider1"]), ]) footer_pile = urwid.Pile([ urwid.Divider(self.g["divider1"]), self.button_columns, ]) self._populate() self.browser_frame = urwid.Frame( self.file_listbox, header=header_pile, footer=footer_pile, ) linebox = urwid.LineBox(self.browser_frame, title="Attach File") super().__init__(linebox) def _update_status(self): pending = self.delegate.pending_attachments if pending: names = [os.path.basename(p) for p in pending] self.status_label.set_text(" "+self.g["file"]+" "+str(len(pending))+" selected: "+", ".join(names)) else: self.status_label.set_text(" No files selected") def _populate(self): self.path_label.set_text(" "+self.current_path) self._update_status() focus_pos = None try: focus_pos = self.file_listbox.focus_position except Exception: pass entries = [] parent = os.path.dirname(self.current_path) if parent != self.current_path: entry = FileBrowserEntry("..", parent, is_parent=True) urwid.connect_signal(entry, "click", self._entry_clicked, entry) entries.append(entry) try: items = sorted(os.listdir(self.current_path)) except PermissionError: entries.append(urwid.Text(("error_text", " Permission denied"))) self.file_walker[:] = entries return dirs = [] files = [] for item in items: if item.startswith("."): continue full = os.path.join(self.current_path, item) if os.path.isdir(full): dirs.append((item, full)) elif os.path.isfile(full): files.append((item, full)) for name, full in dirs: entry = FileBrowserEntry(name, full, is_dir=True) urwid.connect_signal(entry, "click", self._entry_clicked, entry) entries.append(entry) for name, full in files: is_selected = full in self.delegate.pending_attachments entry = FileBrowserEntry(name, full, selected=is_selected) urwid.connect_signal(entry, "click", self._entry_clicked, entry) entries.append(entry) if not dirs and not files: entries.append(urwid.Text(("inactive_text", " (empty)"))) self.file_walker[:] = entries if focus_pos is not None and focus_pos < len(entries): self.file_listbox.set_focus(focus_pos) elif entries: self.file_listbox.set_focus(0) def _entry_clicked(self, entry_widget, user_data=None): entry = user_data if user_data else entry_widget if entry.is_dir or entry.is_parent: self.current_path = entry.full_path self._populate() else: if entry.full_path in self.delegate.pending_attachments: self.delegate.pending_attachments.remove(entry.full_path) else: self.delegate.pending_attachments.append(entry.full_path) self.delegate.frame.contents["footer"] = (self.delegate._build_footer(), None) self._populate() def _dismiss(self, sender): self.delegate.file_browser_closed() def _cancel(self, sender): self.delegate.pending_attachments.clear() self.delegate.frame.contents["footer"] = (self.delegate._build_footer(), None) self.delegate.file_browser_closed() def keypress(self, size, key): if key == "esc": self.delegate.file_browser_closed() return result = super().keypress(size, key) if result == "down" and self.browser_frame.focus_position == "body": self.browser_frame.focus_position = "footer" return elif result == "up" and self.browser_frame.focus_position == "footer": self.browser_frame.focus_position = "body" return return result class SyncProgressBar(urwid.ProgressBar): def get_text(self): status = nomadnet.NomadNetworkApp.get_shared_instance().get_sync_status() show_percent = nomadnet.NomadNetworkApp.get_shared_instance().sync_status_show_percent() if show_percent: return status+" "+super().get_text() else: return status