show connection errors in console

maybe fix aplay

contact/__main__.py

@@ -53,23 +53,22 @@ logging.basicConfig(
 
 app_state.lock = threading.Lock()
 
+
 # ------------------------------------------------------------------------------
 # Main Program Logic
 # ------------------------------------------------------------------------------
-
+def prompt_region_if_unset(args: object) -> None:
-
+    """Prompt user to set region if it is unset."""
-def initialize_globals(args) -> None:
-    """Initializes interface and shared globals."""
-    interface_state.interface = initialize_interface(args)
-
-    # Prompt for region if unset
-    if interface_state.interface.localNode.localConfig.lora.region == 0:
     confirmation = get_list_input("Your region is UNSET. Set it now?", "Yes", ["Yes", "No"])
     if confirmation == "Yes":
         set_region(interface_state.interface)
         interface_state.interface.close()
         interface_state.interface = initialize_interface(args)
 
+
+def initialize_globals(args: object) -> None:
+    """Initializes interface and shared globals."""
+
     interface_state.myNodeNum = get_nodeNum()
     ui_state.channel_list = get_channels()
     ui_state.node_list = get_node_list()
@@ -81,10 +80,9 @@ def initialize_globals(args) -> None:
 
 def main(stdscr: curses.window) -> None:
     """Main entry point for the curses UI."""
-    output_capture = io.StringIO()
 
+    output_capture = io.StringIO()
     try:
-        with contextlib.redirect_stdout(output_capture), contextlib.redirect_stderr(output_capture):
         setup_colors()
         draw_splash(stdscr)
 
@@ -96,39 +94,48 @@ def main(stdscr: curses.window) -> None:
 
         logging.info("Initializing interface...")
         with app_state.lock:
+            interface_state.interface = initialize_interface(args)
+
+            if interface_state.interface.localNode.localConfig.lora.region == 0:
+                prompt_region_if_unset(args)
+
             initialize_globals(args)
             logging.info("Starting main UI")
 
+        try:
+            with contextlib.redirect_stdout(output_capture), contextlib.redirect_stderr(output_capture):
                 main_ui(stdscr)
-
+        except Exception:
-    except Exception as e:
             console_output = output_capture.getvalue()
-        logging.error("Uncaught exception: %s", e)
+            logging.error("Uncaught exception inside main_ui")
-        logging.error("Traceback: %s", traceback.format_exc())
+            logging.error("Traceback:\n%s", traceback.format_exc())
             logging.error("Console output:\n%s", console_output)
+            return
+
+    except Exception:
         raise
 
 
 def start() -> None:
-    """Launch curses wrapper and redirect logs to file."""
+    """Entry point for the application."""
 
     if "--help" in sys.argv or "-h" in sys.argv:
         setup_parser().print_help()
         sys.exit(0)
 
-    with open(config.log_file_path, "a", buffering=1) as log_f:
-        sys.stdout = log_f
-        sys.stderr = log_f
-
-        with contextlib.redirect_stdout(log_f), contextlib.redirect_stderr(log_f):
     try:
         curses.wrapper(main)
     except KeyboardInterrupt:
         logging.info("User exited with Ctrl+C")
         sys.exit(0)
     except Exception as e:
-                logging.error("Fatal error: %s", e)
+        logging.critical("Fatal error", exc_info=True)
-                logging.error("Traceback: %s", traceback.format_exc())
+        try:
+            curses.endwin()
+        except Exception:
+            pass
+        print("Fatal error:", e)
+        traceback.print_exc()
         sys.exit(1)
 
 

contact/message_handlers/rx_handler.py

@@ -1,9 +1,14 @@
 import logging
-import time
+import os
-from datetime import datetime
+import platform
+import shutil
+import subprocess
 from typing import Any, Dict
 
-from contact.utilities.utils import refresh_node_list
+from contact.utilities.utils import (
+    refresh_node_list,
+    add_new_message,
+)
 from contact.ui.contact_ui import (
     draw_packetlog_win,
     draw_node_list,
@@ -22,6 +27,46 @@ import contact.ui.default_config as config
 from contact.utilities.singleton import ui_state, interface_state, app_state
 
 
+def play_sound():
+    try:
+        system = platform.system()
+        sound_path = None
+        executable = None
+
+        if system == "Darwin":  # macOS
+            sound_path = "/System/Library/Sounds/Ping.aiff"
+            executable = "afplay"
+
+        elif system == "Linux":
+            ogg_path = "/usr/share/sounds/freedesktop/stereo/complete.oga"
+            wav_path = "/usr/share/sounds/alsa/Front_Center.wav"  # common fallback
+
+            if shutil.which("paplay") and os.path.exists(ogg_path):
+                executable = "paplay"
+                sound_path = ogg_path
+            elif shutil.which("ffplay") and os.path.exists(ogg_path):
+                executable = "ffplay"
+                sound_path = ogg_path
+            elif shutil.which("aplay") and os.path.exists(wav_path):
+                executable = "aplay"
+                sound_path = wav_path
+            else:
+                logging.warning("No suitable sound player or sound file found on Linux")
+
+        if executable and sound_path:
+            cmd = [executable, sound_path]
+            if executable == "ffplay":
+                cmd = [executable, "-nodisp", "-autoexit", sound_path]
+
+            subprocess.run(cmd, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
+            return
+
+    except subprocess.CalledProcessError as e:
+        logging.error(f"Sound playback failed: {e}")
+    except Exception as e:
+        logging.error(f"Unexpected error: {e}")
+
+
 def on_receive(packet: Dict[str, Any], interface: Any) -> None:
     """
     Handles an incoming packet from a Meshtastic interface.
@@ -53,6 +98,10 @@ def on_receive(packet: Dict[str, Any], interface: Any) -> None:
                     maybe_store_nodeinfo_in_db(packet)
 
             elif packet["decoded"]["portnum"] == "TEXT_MESSAGE_APP":
+
+                if config.notification_sound == "True":
+                    play_sound()
+
                 message_bytes = packet["decoded"]["payload"]
                 message_string = message_bytes.decode("utf-8")
 
@@ -76,7 +125,9 @@ def on_receive(packet: Dict[str, Any], interface: Any) -> None:
 
                     channel_number = ui_state.channel_list.index(packet["from"])
 
-                if ui_state.channel_list[channel_number] != ui_state.channel_list[ui_state.selected_channel]:
+                channel_id = ui_state.channel_list[channel_number]
+
+                if channel_id != ui_state.channel_list[ui_state.selected_channel]:
                     add_notification(channel_number)
                     refresh_channels = True
                 else:
@@ -86,40 +137,14 @@ def on_receive(packet: Dict[str, Any], interface: Any) -> None:
                 message_from_id = packet["from"]
                 message_from_string = get_name_from_database(message_from_id, type="short") + ":"
 
-                if ui_state.channel_list[channel_number] not in ui_state.all_messages:
+                add_new_message(channel_id, f"{config.message_prefix} {message_from_string} ", message_string)
-                    ui_state.all_messages[ui_state.channel_list[channel_number]] = []
-
-                # Timestamp handling
-                current_timestamp = time.time()
-                current_hour = datetime.fromtimestamp(current_timestamp).strftime("%Y-%m-%d %H:00")
-
-                # Retrieve the last timestamp if available
-                channel_messages = ui_state.all_messages[ui_state.channel_list[channel_number]]
-                if channel_messages:
-                    # Check the last entry for a timestamp
-                    for entry in reversed(channel_messages):
-                        if entry[0].startswith("--"):
-                            last_hour = entry[0].strip("- ").strip()
-                            break
-                    else:
-                        last_hour = None
-                else:
-                    last_hour = None
-
-                # Add a new timestamp if it's a new hour
-                if last_hour != current_hour:
-                    ui_state.all_messages[ui_state.channel_list[channel_number]].append((f"-- {current_hour} --", ""))
-
-                ui_state.all_messages[ui_state.channel_list[channel_number]].append(
-                    (f"{config.message_prefix} {message_from_string} ", message_string)
-                )
 
                 if refresh_channels:
                     draw_channel_list()
                 if refresh_messages:
                     draw_messages_window(True)
 
-                save_message_to_db(ui_state.channel_list[channel_number], message_from_id, message_string)
+                save_message_to_db(channel_id, message_from_id, message_string)
 
         except KeyError as e:
             logging.error(f"Error processing packet: {e}")

contact/message_handlers/tx_handler.py

@@ -1,4 +1,3 @@
-from datetime import datetime
 from typing import Any, Dict
 
 import google.protobuf.json_format
@@ -16,6 +15,8 @@ import contact.ui.default_config as config
 
 from contact.utilities.singleton import ui_state, interface_state
 
+from contact.utilities.utils import add_new_message
+
 ack_naks: Dict[str, Dict[str, Any]] = {}  # requestId -> {channel, messageIndex, timestamp}
 
 
@@ -146,8 +147,9 @@ def on_response_traceroute(packet: Dict[str, Any]) -> None:
         update_node_info_in_db(packet["from"], chat_archived=False)
 
     channel_number = ui_state.channel_list.index(packet["from"])
+    channel_id = ui_state.channel_list[channel_number]
 
-    if ui_state.channel_list[channel_number] == ui_state.channel_list[ui_state.selected_channel]:
+    if channel_id == ui_state.channel_list[ui_state.selected_channel]:
         refresh_messages = True
     else:
         add_notification(channel_number)
@@ -155,18 +157,14 @@ def on_response_traceroute(packet: Dict[str, Any]) -> None:
 
     message_from_string = get_name_from_database(packet["from"], type="short") + ":\n"
 
-    if ui_state.channel_list[channel_number] not in ui_state.all_messages:
+    add_new_message(channel_id, f"{config.message_prefix} {message_from_string}", msg_str)
-        ui_state.all_messages[ui_state.channel_list[channel_number]] = []
-    ui_state.all_messages[ui_state.channel_list[channel_number]].append(
-        (f"{config.message_prefix} {message_from_string}", msg_str)
-    )
 
     if refresh_channels:
         draw_channel_list()
     if refresh_messages:
         draw_messages_window(True)
-    save_message_to_db(ui_state.channel_list[channel_number], packet["from"], msg_str)
 
+    save_message_to_db(channel_id, packet["from"], msg_str)
 
 def send_message(message: str, destination: int = BROADCAST_NUM, channel: int = 0) -> None:
     """
@@ -190,32 +188,7 @@ def send_message(message: str, destination: int = BROADCAST_NUM, channel: int =
         channelIndex=send_on_channel,
     )
 
-    # Add sent message to the messages dictionary
+    add_new_message(channel_id, config.sent_message_prefix + config.ack_unknown_str + ": ", message)
-    if channel_id not in ui_state.all_messages:
-        ui_state.all_messages[channel_id] = []
-
-    # Handle timestamp logic
-    current_timestamp = int(datetime.now().timestamp())  # Get current timestamp
-    current_hour = datetime.fromtimestamp(current_timestamp).strftime("%Y-%m-%d %H:00")
-
-    # Retrieve the last timestamp if available
-    channel_messages = ui_state.all_messages[channel_id]
-    if channel_messages:
-        # Check the last entry for a timestamp
-        for entry in reversed(channel_messages):
-            if entry[0].startswith("--"):
-                last_hour = entry[0].strip("- ").strip()
-                break
-        else:
-            last_hour = None
-    else:
-        last_hour = None
-
-    # Add a new timestamp if it's a new hour
-    if last_hour != current_hour:
-        ui_state.all_messages[channel_id].append((f"-- {current_hour} --", ""))
-
-    ui_state.all_messages[channel_id].append((config.sent_message_prefix + config.ack_unknown_str + ": ", message))
 
     timestamp = save_message_to_db(channel_id, myid, message)
 
@@ -230,10 +203,14 @@ def send_traceroute() -> None:
     """
     Sends a RouteDiscovery protobuf to the selected node.
     """
+
+    channel_id = ui_state.node_list[ui_state.selected_node]
+    add_new_message(channel_id, f"{config.message_prefix} Sent Traceroute", "")
+
     r = mesh_pb2.RouteDiscovery()
     interface_state.interface.sendData(
         r,
-        destinationId=ui_state.node_list[ui_state.selected_node],
+        destinationId=channel_id,
         portNum=portnums_pb2.PortNum.TRACEROUTE_APP,
         wantResponse=True,
         onResponse=on_response_traceroute,

contact/ui/contact_ui.py

@@ -1,5 +1,4 @@
 import curses
-import textwrap
 import logging
 import traceback
 from typing import Union
@@ -12,29 +11,36 @@ from contact.utilities.db_handler import get_name_from_database, update_node_inf
 from contact.utilities.input_handlers import get_list_input
 import contact.ui.default_config as config
 import contact.ui.dialog
-
+from contact.ui.nav_utils import move_main_highlight, draw_main_arrows, get_msg_window_lines, wrap_text
-
 from contact.utilities.singleton import ui_state, interface_state
 
 
 def handle_resize(stdscr: curses.window, firstrun: bool) -> None:
+    """Handle terminal resize events and redraw the UI accordingly."""
     global messages_pad, messages_win, nodes_pad, nodes_win, channel_pad, channel_win, function_win, packetlog_win, entry_win
 
     # Calculate window max dimensions
     height, width = stdscr.getmaxyx()
 
     # Define window dimensions and positions
-    channel_width = 3 * (width // 16)
+    channel_width = int(config.channel_list_16ths) * (width // 16)
-    nodes_width = 5 * (width // 16)
+    nodes_width = int(config.node_list_16ths) * (width // 16)
     messages_width = width - channel_width - nodes_width
 
+    entry_height = 3
+    function_height = 3
+    y_pad = entry_height + function_height
+    packet_log_height = int(height / 3)
+
     if firstrun:
-        entry_win = curses.newwin(3, width, 0, 0)
+        entry_win = curses.newwin(entry_height, width, 0, 0)
-        channel_win = curses.newwin(height - 6, channel_width, 3, 0)
+        channel_win = curses.newwin(height - y_pad, channel_width, entry_height, 0)
-        messages_win = curses.newwin(height - 6, messages_width, 3, channel_width)
+        messages_win = curses.newwin(height - y_pad, messages_width, entry_height, channel_width)
-        nodes_win = curses.newwin(height - 6, nodes_width, 3, channel_width + messages_width)
+        nodes_win = curses.newwin(height - y_pad, nodes_width, entry_height, channel_width + messages_width)
-        function_win = curses.newwin(3, width, height - 3, 0)
+        function_win = curses.newwin(function_height, width, height - function_height, 0)
-        packetlog_win = curses.newwin(int(height / 3), messages_width, height - int(height / 3) - 3, channel_width)
+        packetlog_win = curses.newwin(
+            packet_log_height, messages_width, height - packet_log_height - function_height, channel_width
+        )
 
         # Will be resized to what we need when drawn
         messages_pad = curses.newpad(1, 1)
@@ -59,19 +65,19 @@ def handle_resize(stdscr: curses.window, firstrun: bool) -> None:
 
         entry_win.resize(3, width)
 
-        channel_win.resize(height - 6, channel_width)
+        channel_win.resize(height - y_pad, channel_width)
 
-        messages_win.resize(height - 6, messages_width)
+        messages_win.resize(height - y_pad, messages_width)
         messages_win.mvwin(3, channel_width)
 
-        nodes_win.resize(height - 6, nodes_width)
+        nodes_win.resize(height - y_pad, nodes_width)
-        nodes_win.mvwin(3, channel_width + messages_width)
+        nodes_win.mvwin(entry_height, channel_width + messages_width)
 
         function_win.resize(3, width)
-        function_win.mvwin(height - 3, 0)
+        function_win.mvwin(height - function_height, 0)
 
-        packetlog_win.resize(int(height / 3), messages_width)
+        packetlog_win.resize(packet_log_height, messages_width)
-        packetlog_win.mvwin(height - int(height / 3) - 3, channel_width)
+        packetlog_win.mvwin(height - packet_log_height - function_height, channel_width)
 
     # Draw window borders
     for win in [channel_win, entry_win, nodes_win, messages_win, function_win]:
@@ -86,6 +92,7 @@ def handle_resize(stdscr: curses.window, firstrun: bool) -> None:
         draw_channel_list()
         draw_messages_window(True)
         draw_node_list()
+
     except:
         # Resize events can come faster than we can re-draw, which can cause a curses error.
         # In this case we'll see another curses.KEY_RESIZE in our key handler and draw again later.
@@ -93,6 +100,7 @@ def handle_resize(stdscr: curses.window, firstrun: bool) -> None:
 
 
 def main_ui(stdscr: curses.window) -> None:
+    """Main UI loop for the curses interface."""
     global input_text
     input_text = ""
     stdscr.keypad(True)
@@ -100,7 +108,7 @@ def main_ui(stdscr: curses.window) -> None:
     handle_resize(stdscr, True)
 
     while True:
-        draw_text_field(entry_win, f"Input: {input_text[-(stdscr.getmaxyx()[1] - 10):]}", get_color("input"))
+        draw_text_field(entry_win, f"Input: {(input_text or '')[-(stdscr.getmaxyx()[1] - 10):]}", get_color("input"))
 
         # Get user input from entry window
         char = entry_win.get_wch()
@@ -108,6 +116,70 @@ def main_ui(stdscr: curses.window) -> None:
         # draw_debug(f"Keypress: {char}")
 
         if char == curses.KEY_UP:
+            handle_up()
+
+        elif char == curses.KEY_DOWN:
+            handle_down()
+
+        elif char == curses.KEY_HOME:
+            handle_home()
+
+        elif char == curses.KEY_END:
+            handle_end()
+
+        elif char == curses.KEY_PPAGE:
+            handle_pageup()
+
+        elif char == curses.KEY_NPAGE:
+            handle_pagedown()
+
+        elif char == curses.KEY_LEFT or char == curses.KEY_RIGHT:
+            handle_leftright(char)
+
+        elif char in (chr(curses.KEY_ENTER), chr(10), chr(13)):
+            input_text = handle_enter(input_text)
+
+        elif char == chr(20):  # Ctrl + t for Traceroute
+            handle_ctrl_t(stdscr)
+
+        elif char in (curses.KEY_BACKSPACE, chr(127)):
+            input_text = handle_backspace(entry_win, input_text)
+
+        elif char == "`":  # ` Launch the settings interface
+            handle_backtick(stdscr)
+
+        elif char == chr(16):  # Ctrl + P for Packet Log
+            handle_ctrl_p()
+
+        elif char == curses.KEY_RESIZE:
+            input_text = ""
+            handle_resize(stdscr, False)
+
+        elif char == chr(4):  # Ctrl + D to delete current channel or node
+            handle_ctrl_d()
+
+        elif char == chr(31):  # Ctrl + / to search
+            handle_ctrl_fslash()
+
+        elif char == chr(6):  # Ctrl + F to toggle favorite
+            handle_ctrl_f(stdscr)
+
+        elif char == chr(7):  # Ctrl + G to toggle ignored
+            handle_ctlr_g(stdscr)
+
+        elif char == chr(27):  # Escape to exit
+            break
+
+        else:
+            # Append typed character to input text
+            if isinstance(char, str):
+                input_text += char
+            else:
+                input_text += chr(char)
+
+
+def handle_up() -> None:
+    """Handle key up events to scroll the current window."""
     if ui_state.current_window == 0:
         scroll_channels(-1)
     elif ui_state.current_window == 1:
@@ -115,7 +187,9 @@ def main_ui(stdscr: curses.window) -> None:
     elif ui_state.current_window == 2:
         scroll_nodes(-1)
 
-        elif char == curses.KEY_DOWN:
+
+def handle_down() -> None:
+    """Handle key down events to scroll the current window."""
     if ui_state.current_window == 0:
         scroll_channels(1)
     elif ui_state.current_window == 1:
@@ -123,7 +197,9 @@ def main_ui(stdscr: curses.window) -> None:
     elif ui_state.current_window == 2:
         scroll_nodes(1)
 
-        elif char == curses.KEY_HOME:
+
+def handle_home() -> None:
+    """Handle home key events to select the first item in the current window."""
     if ui_state.current_window == 0:
         select_channel(0)
     elif ui_state.current_window == 1:
@@ -132,30 +208,36 @@ def main_ui(stdscr: curses.window) -> None:
     elif ui_state.current_window == 2:
         select_node(0)
 
-        elif char == curses.KEY_END:
+
+def handle_end() -> None:
+    """Handle end key events to select the last item in the current window."""
     if ui_state.current_window == 0:
         select_channel(len(ui_state.channel_list) - 1)
     elif ui_state.current_window == 1:
         msg_line_count = messages_pad.getmaxyx()[0]
-                ui_state.selected_message = max(msg_line_count - get_msg_window_lines(), 0)
+        ui_state.selected_message = max(msg_line_count - get_msg_window_lines(messages_win, packetlog_win), 0)
         refresh_pad(1)
     elif ui_state.current_window == 2:
         select_node(len(ui_state.node_list) - 1)
 
-        elif char == curses.KEY_PPAGE:
+
+def handle_pageup() -> None:
+    """Handle page up key events to scroll the current window by a page."""
     if ui_state.current_window == 0:
         select_channel(
             ui_state.selected_channel - (channel_win.getmaxyx()[0] - 2)
         )  # select_channel will bounds check for us
     elif ui_state.current_window == 1:
-                ui_state.selected_message = max(ui_state.selected_message - get_msg_window_lines(), 0)
+        ui_state.selected_message = max(
+            ui_state.selected_message - get_msg_window_lines(messages_win, packetlog_win), 0
+        )
         refresh_pad(1)
     elif ui_state.current_window == 2:
-                select_node(
+        select_node(ui_state.selected_node - (nodes_win.getmaxyx()[0] - 2))  # select_node will bounds check for us
-                    ui_state.selected_node - (nodes_win.getmaxyx()[0] - 2)
-                )  # select_node will bounds check for us
 
-        elif char == curses.KEY_NPAGE:
+
+def handle_pagedown() -> None:
+    """Handle page down key events to scroll the current window down."""
     if ui_state.current_window == 0:
         select_channel(
             ui_state.selected_channel + (channel_win.getmaxyx()[0] - 2)
@@ -163,17 +245,17 @@ def main_ui(stdscr: curses.window) -> None:
     elif ui_state.current_window == 1:
         msg_line_count = messages_pad.getmaxyx()[0]
         ui_state.selected_message = min(
-                    ui_state.selected_message + get_msg_window_lines(), msg_line_count - get_msg_window_lines()
+            ui_state.selected_message + get_msg_window_lines(messages_win, packetlog_win),
+            msg_line_count - get_msg_window_lines(messages_win, packetlog_win),
         )
         refresh_pad(1)
     elif ui_state.current_window == 2:
-                select_node(
+        select_node(ui_state.selected_node + (nodes_win.getmaxyx()[0] - 2))  # select_node will bounds check for us
-                    ui_state.selected_node + (nodes_win.getmaxyx()[0] - 2)
-                )  # select_node will bounds check for us
 
-        elif char == curses.KEY_LEFT or char == curses.KEY_RIGHT:
+
+def handle_leftright(char: int) -> None:
+    """Handle left/right key events to switch between windows."""
     delta = -1 if char == curses.KEY_LEFT else 1
-
     old_window = ui_state.current_window
     ui_state.current_window = (ui_state.current_window + delta) % 3
 
@@ -181,7 +263,6 @@ def main_ui(stdscr: curses.window) -> None:
         channel_win.attrset(get_color("window_frame"))
         channel_win.box()
         channel_win.refresh()
-                highlight_line(False, 0, ui_state.selected_channel)
         refresh_pad(0)
     if old_window == 1:
         messages_win.attrset(get_color("window_frame"))
@@ -193,7 +274,6 @@ def main_ui(stdscr: curses.window) -> None:
         nodes_win.attrset(get_color("window_frame"))
         nodes_win.box()
         nodes_win.refresh()
-                highlight_line(False, 2, ui_state.selected_node)
         refresh_pad(2)
 
     if ui_state.current_window == 0:
@@ -201,7 +281,6 @@ def main_ui(stdscr: curses.window) -> None:
         channel_win.box()
         channel_win.attrset(get_color("window_frame"))
         channel_win.refresh()
-                highlight_line(True, 0, ui_state.selected_channel)
         refresh_pad(0)
     elif ui_state.current_window == 1:
         messages_win.attrset(get_color("window_frame_selected"))
@@ -215,26 +294,11 @@ def main_ui(stdscr: curses.window) -> None:
         nodes_win.box()
         nodes_win.attrset(get_color("window_frame"))
         nodes_win.refresh()
-                highlight_line(True, 2, ui_state.selected_node)
         refresh_pad(2)
 
-        # Check for Esc
-        elif char == chr(27):
-            break
 
-        # Check for Ctrl + t
+def handle_enter(input_text: str) -> str:
-        elif char == chr(20):
+    """Handle Enter key events to send messages or select channels."""
-            send_traceroute()
-            curses.curs_set(0)  # Hide cursor
-            contact.ui.dialog.dialog(
-                stdscr,
-                "Traceroute Sent",
-                "Results will appear in messages window.\nNote: Traceroute is limited to once every 30 seconds.",
-            )
-            curses.curs_set(1)  # Show cursor again
-            handle_resize(stdscr, False)
-
-        elif char in (chr(curses.KEY_ENTER), chr(10), chr(13)):
     if ui_state.current_window == 2:
         node_list = ui_state.node_list
         if node_list[ui_state.selected_node] not in ui_state.channel_list:
@@ -253,6 +317,7 @@ def main_ui(stdscr: curses.window) -> None:
         draw_node_list()
         draw_channel_list()
         draw_messages_window(True)
+        return input_text
 
     elif len(input_text) > 0:
         # Enter key pressed, send user input as message
@@ -260,10 +325,26 @@ def main_ui(stdscr: curses.window) -> None:
         draw_messages_window(True)
 
         # Clear entry window and reset input text
-                input_text = ""
         entry_win.erase()
+        return ""
+    return input_text
 
-        elif char in (curses.KEY_BACKSPACE, chr(127)):
+
+def handle_ctrl_t(stdscr: curses.window) -> None:
+    """Handle Ctrl + T key events to send a traceroute."""
+    send_traceroute()
+    curses.curs_set(0)  # Hide cursor
+    contact.ui.dialog.dialog(
+        stdscr,
+        f"Traceroute Sent To: {get_name_from_database(ui_state.node_list[ui_state.selected_node])}",
+        "Results will appear in messages window.\nNote: Traceroute is limited to once every 30 seconds.",
+    )
+    curses.curs_set(1)  # Show cursor again
+    handle_resize(stdscr, False)
+
+
+def handle_backspace(entry_win: curses.window, input_text: str) -> str:
+    """Handle backspace key events to remove the last character from input text."""
     if input_text:
         input_text = input_text[:-1]
         y, x = entry_win.getyx()
@@ -271,15 +352,20 @@ def main_ui(stdscr: curses.window) -> None:
         entry_win.addch(" ")  #
         entry_win.move(y, x - 1)
     entry_win.refresh()
+    return input_text
 
-        elif char == "`":  # ` Launch the settings interface
+
+def handle_backtick(stdscr: curses.window) -> None:
+    """Handle backtick key events to open the settings menu."""
     curses.curs_set(0)
     settings_menu(stdscr, interface_state.interface)
     curses.curs_set(1)
     refresh_node_list()
     handle_resize(stdscr, False)
 
-        elif char == chr(16):
+
+def handle_ctrl_p() -> None:
+    """Handle Ctrl + P key events to toggle the packet log display."""
     # Display packet log
     if ui_state.display_log is False:
         ui_state.display_log = True
@@ -289,12 +375,8 @@ def main_ui(stdscr: curses.window) -> None:
         packetlog_win.erase()
         draw_messages_window(True)
 
-        elif char == curses.KEY_RESIZE:
-            input_text = ""
-            handle_resize(stdscr, False)
 
-        # ^D
+def handle_ctrl_d() -> None:
-        elif char == chr(4):
     if ui_state.current_window == 0:
         if isinstance(ui_state.channel_list[ui_state.selected_channel], int):
             update_node_info_in_db(ui_state.channel_list[ui_state.selected_channel], chat_archived=True)
@@ -334,15 +416,16 @@ def main_ui(stdscr: curses.window) -> None:
         else:
             draw_messages_window()
         curses.curs_set(1)
-                continue
 
-        # ^/
+
-        elif char == chr(31):
+def handle_ctrl_fslash() -> None:
+    """Handle Ctrl + / key events to search in the current window."""
     if ui_state.current_window == 2 or ui_state.current_window == 0:
         search(ui_state.current_window)
 
-        # ^F
+
-        elif char == chr(6):
+def handle_ctrl_f(stdscr: curses.window) -> None:
+    """Handle Ctrl + F key events to toggle favorite status of the selected node."""
     if ui_state.current_window == 2:
         selectedNode = interface_state.interface.nodesByNum[ui_state.node_list[ui_state.selected_node]]
 
@@ -357,9 +440,7 @@ def main_ui(stdscr: curses.window) -> None:
             if confirmation == "Yes":
                 interface_state.interface.localNode.setFavorite(ui_state.node_list[ui_state.selected_node])
                 # Maybe we shouldn't be modifying the nodedb, but maybe it should update itself
-                        interface_state.interface.nodesByNum[ui_state.node_list[ui_state.selected_node]][
+                interface_state.interface.nodesByNum[ui_state.node_list[ui_state.selected_node]]["isFavorite"] = True
-                            "isFavorite"
-                        ] = True
 
                 refresh_node_list()
 
@@ -372,15 +453,15 @@ def main_ui(stdscr: curses.window) -> None:
             if confirmation == "Yes":
                 interface_state.interface.localNode.removeFavorite(ui_state.node_list[ui_state.selected_node])
                 # Maybe we shouldn't be modifying the nodedb, but maybe it should update itself
-                        interface_state.interface.nodesByNum[ui_state.node_list[ui_state.selected_node]][
+                interface_state.interface.nodesByNum[ui_state.node_list[ui_state.selected_node]]["isFavorite"] = False
-                            "isFavorite"
-                        ] = False
 
                 refresh_node_list()
 
         handle_resize(stdscr, False)
 
-        elif char == chr(7):
+
+def handle_ctlr_g(stdscr: curses.window) -> None:
+    """Handle Ctrl + G key events to toggle ignored status of the selected node."""
     if ui_state.current_window == 2:
         selectedNode = interface_state.interface.nodesByNum[ui_state.node_list[ui_state.selected_node]]
 
@@ -394,9 +475,7 @@ def main_ui(stdscr: curses.window) -> None:
             )
             if confirmation == "Yes":
                 interface_state.interface.localNode.setIgnored(ui_state.node_list[ui_state.selected_node])
-                        interface_state.interface.nodesByNum[ui_state.node_list[ui_state.selected_node]][
+                interface_state.interface.nodesByNum[ui_state.node_list[ui_state.selected_node]]["isIgnored"] = True
-                            "isIgnored"
-                        ] = True
         else:
             confirmation = get_list_input(
                 f"Remove {get_name_from_database(ui_state.node_list[ui_state.selected_node])} from Ignored?",
@@ -405,24 +484,15 @@ def main_ui(stdscr: curses.window) -> None:
             )
             if confirmation == "Yes":
                 interface_state.interface.localNode.removeIgnored(ui_state.node_list[ui_state.selected_node])
-                        interface_state.interface.nodesByNum[ui_state.node_list[ui_state.selected_node]][
+                interface_state.interface.nodesByNum[ui_state.node_list[ui_state.selected_node]]["isIgnored"] = False
-                            "isIgnored"
-                        ] = False
 
         handle_resize(stdscr, False)
 
-        else:
-            # Append typed character to input text
-            if isinstance(char, str):
-                input_text += char
-            else:
-                input_text += chr(char)
-
 
 def draw_channel_list() -> None:
+    """Update the channel list window and pad based on the current state."""
     channel_pad.erase()
-    win_height, win_width = channel_win.getmaxyx()
+    win_width = channel_win.getmaxyx()[1]
-    start_index = max(0, ui_state.selected_channel - (win_height - 3))  # Leave room for borders
 
     channel_pad.resize(len(ui_state.all_messages), channel_win.getmaxyx()[1])
 
@@ -460,6 +530,8 @@ def draw_channel_list() -> None:
     )
     channel_win.box()
     channel_win.attrset((get_color("window_frame")))
+
+    draw_main_arrows(channel_win, len(ui_state.channel_list), window=0)
     channel_win.refresh()
 
     refresh_pad(0)
@@ -479,7 +551,7 @@ def draw_messages_window(scroll_to_bottom: bool = False) -> None:
         row = 0
         for prefix, message in messages:
             full_message = f"{prefix}{message}"
-            wrapped_lines = textwrap.wrap(full_message, messages_win.getmaxyx()[1] - 2)
+            wrapped_lines = wrap_text(full_message, messages_win.getmaxyx()[1] - 2)
             msg_line_count += len(wrapped_lines)
             messages_pad.resize(msg_line_count, messages_win.getmaxyx()[1])
 
@@ -501,10 +573,22 @@ def draw_messages_window(scroll_to_bottom: bool = False) -> None:
     messages_win.attrset(get_color("window_frame"))
     messages_win.refresh()
 
+    visible_lines = get_msg_window_lines(messages_win, packetlog_win)
+
     if scroll_to_bottom:
-        ui_state.selected_message = max(msg_line_count - get_msg_window_lines(), 0)
+        ui_state.selected_message = max(msg_line_count - visible_lines, 0)
+        ui_state.start_index[1] = max(msg_line_count - visible_lines, 0)
+        pass
     else:
-        ui_state.selected_message = max(min(ui_state.selected_message, msg_line_count - get_msg_window_lines()), 0)
+        ui_state.selected_message = max(min(ui_state.selected_message, msg_line_count - visible_lines), 0)
+
+    draw_main_arrows(
+        messages_win,
+        msg_line_count,
+        window=1,
+        log_height=packetlog_win.getmaxyx()[0],
+    )
+    messages_win.refresh()
 
     refresh_pad(1)
 
@@ -512,6 +596,7 @@ def draw_messages_window(scroll_to_bottom: bool = False) -> None:
 
 
 def draw_node_list() -> None:
+    """Update the nodes list window and pad based on the current state."""
     global nodes_pad
 
     # This didn't work, for some reason an error is thown on startup, so we just create the pad every time
@@ -547,6 +632,8 @@ def draw_node_list() -> None:
     )
     nodes_win.box()
     nodes_win.attrset(get_color("window_frame"))
+
+    draw_main_arrows(nodes_win, len(ui_state.node_list), window=2)
     nodes_win.refresh()
 
     refresh_pad(2)
@@ -558,6 +645,7 @@ def draw_node_list() -> None:
 
 
 def select_channel(idx: int) -> None:
+    """Select a channel by index and update the UI state accordingly."""
     old_selected_channel = ui_state.selected_channel
     ui_state.selected_channel = max(0, min(idx, len(ui_state.channel_list) - 1))
     draw_messages_window(True)
@@ -567,12 +655,19 @@ def select_channel(idx: int) -> None:
         remove_notification(ui_state.selected_channel)
         draw_channel_list()
         return
-    highlight_line(False, 0, old_selected_channel)
+
-    highlight_line(True, 0, ui_state.selected_channel)
+    move_main_highlight(
-    refresh_pad(0)
+        old_idx=old_selected_channel,
+        new_idx=ui_state.selected_channel,
+        options=ui_state.channel_list,
+        menu_win=channel_win,
+        menu_pad=channel_pad,
+        ui_state=ui_state,
+    )
 
 
 def scroll_channels(direction: int) -> None:
+    """Scroll through the channel list by a given direction."""
     new_selected_channel = ui_state.selected_channel + direction
 
     if new_selected_channel < 0:
@@ -584,26 +679,57 @@ def scroll_channels(direction: int) -> None:
 
 
 def scroll_messages(direction: int) -> None:
+    """Scroll through the messages in the current channel by a given direction."""
     ui_state.selected_message += direction
 
     msg_line_count = messages_pad.getmaxyx()[0]
-    ui_state.selected_message = max(0, min(ui_state.selected_message, msg_line_count - get_msg_window_lines()))
+    ui_state.selected_message = max(
+        0, min(ui_state.selected_message, msg_line_count - get_msg_window_lines(messages_win, packetlog_win))
+    )
+
+    max_index = msg_line_count - 1
+    visible_height = get_msg_window_lines(messages_win, packetlog_win)
+
+    if ui_state.selected_message < ui_state.start_index[ui_state.current_window]:  # Moving above the visible area
+        ui_state.start_index[ui_state.current_window] = ui_state.selected_message
+    elif ui_state.selected_message >= ui_state.start_index[ui_state.current_window]:  # Moving below the visible area
+        ui_state.start_index[ui_state.current_window] = ui_state.selected_message
+
+    # Ensure start_index is within bounds
+    ui_state.start_index[ui_state.current_window] = max(
+        0, min(ui_state.start_index[ui_state.current_window], max_index - visible_height + 1)
+    )
+
+    draw_main_arrows(
+        messages_win,
+        msg_line_count,
+        ui_state.current_window,
+        log_height=packetlog_win.getmaxyx()[0],
+    )
+    messages_win.refresh()
 
     refresh_pad(1)
 
 
 def select_node(idx: int) -> None:
+    """Select a node by index and update the UI state accordingly."""
     old_selected_node = ui_state.selected_node
     ui_state.selected_node = max(0, min(idx, len(ui_state.node_list) - 1))
 
-    highlight_line(False, 2, old_selected_node)
+    move_main_highlight(
-    highlight_line(True, 2, ui_state.selected_node)
+        old_idx=old_selected_node,
-    refresh_pad(2)
+        new_idx=ui_state.selected_node,
+        options=ui_state.node_list,
+        menu_win=nodes_win,
+        menu_pad=nodes_pad,
+        ui_state=ui_state,
+    )
 
     draw_function_win()
 
 
 def scroll_nodes(direction: int) -> None:
+    """Scroll through the node list by a given direction."""
     new_selected_node = ui_state.selected_node + direction
 
     if new_selected_node < 0:
@@ -615,7 +741,7 @@ def scroll_nodes(direction: int) -> None:
 
 
 def draw_packetlog_win() -> None:
-
+    """Draw the packet log window with the latest packets."""
     columns = [10, 10, 15, 30]
     span = 0
 
@@ -668,6 +794,7 @@ def draw_packetlog_win() -> None:
 
 
 def search(win: int) -> None:
+    """Search for a node or channel based on user input."""
     start_idx = ui_state.selected_node
     select_func = select_node
 
@@ -716,6 +843,7 @@ def search(win: int) -> None:
 
 
 def draw_node_details() -> None:
+    """Draw the details of the selected node in the function window."""
     node = None
     try:
         node = interface_state.interface.nodesByNum[ui_state.node_list[ui_state.selected_node]]
@@ -779,16 +907,18 @@ def draw_node_details() -> None:
 
 
 def draw_help() -> None:
+    """Draw the help text in the function window."""
     cmds = [
         "↑→↓← = Select",
         "   ENTER = Send",
         "   ` = Settings",
-        "    ^P = Packet Log",
         "   ESC = Quit",
+        "   ^P = Packet Log",
         "   ^t = Traceroute",
         "   ^d = Archive Chat",
         "   ^f = Favorite",
         "   ^g = Ignore",
+        "   ^/ = Search",
     ]
     function_str = ""
     for s in cmds:
@@ -805,11 +935,6 @@ def draw_function_win() -> None:
         draw_help()
 
 
-def get_msg_window_lines() -> None:
-    packetlog_height = packetlog_win.getmaxyx()[0] - 1 if ui_state.display_log else 0
-    return messages_win.getmaxyx()[0] - 2 - packetlog_height
-
-
 def refresh_pad(window: int) -> None:
 
     win_height = channel_win.getmaxyx()[0]
@@ -817,7 +942,7 @@ def refresh_pad(window: int) -> None:
     if window == 1:
         pad = messages_pad
         box = messages_win
-        lines = get_msg_window_lines()
+        lines = get_msg_window_lines(messages_win, packetlog_win)
         selected_item = ui_state.selected_message
         start_index = ui_state.selected_message
 
@@ -845,34 +970,10 @@ def refresh_pad(window: int) -> None:
         box.getbegyx()[0] + 1,
         box.getbegyx()[1] + 1,
         box.getbegyx()[0] + lines,
-        box.getbegyx()[1] + box.getmaxyx()[1] - 2,
+        box.getbegyx()[1] + box.getmaxyx()[1] - 3,
     )
 
 
-def highlight_line(highlight: bool, window: int, line: int) -> None:
-    pad = nodes_pad
-
-    color = get_color("node_list")
-    select_len = nodes_win.getmaxyx()[1] - 2
-
-    if window == 2:
-        node_num = ui_state.node_list[line]
-        node = interface_state.interface.nodesByNum[node_num]
-        if "isFavorite" in node and node["isFavorite"]:
-            color = get_color("node_favorite")
-        if "isIgnored" in node and node["isIgnored"]:
-            color = get_color("node_ignored")
-
-    if window == 0:
-        pad = channel_pad
-        color = get_color(
-            "channel_selected" if (line == ui_state.selected_channel and highlight == False) else "channel_list"
-        )
-        select_len = channel_win.getmaxyx()[1] - 2
-
-    pad.chgat(line, 1, select_len, color | curses.A_REVERSE if highlight else color)
-
-
 def add_notification(channel_number: int) -> None:
     if channel_number not in ui_state.notifications:
         ui_state.notifications.append(channel_number)

contact/ui/default_config.py

@@ -123,15 +123,18 @@ def initialize_config() -> Dict[str, object]:
         "settings_breadcrumbs": ["green", "black"],
         "settings_warning": ["green", "black"],
         "settings_note": ["green", "black"],
-        "node_favorite": ["cyan", "white"],
+        "node_favorite": ["cyan", "green"],
-        "node_ignored": ["red", "white"],
+        "node_ignored": ["red", "black"],
     }
     default_config_variables = {
+        "channel_list_16ths": "3",
+        "node_list_16ths": "5",
         "db_file_path": db_file_path,
         "log_file_path": log_file_path,
         "message_prefix": ">>",
         "sent_message_prefix": ">> Sent",
         "notification_symbol": "*",
+        "notification_sound": "True",
         "ack_implicit_str": "[◌]",
         "ack_str": "[✓]",
         "nak_str": "[x]",
@@ -170,18 +173,23 @@ def assign_config_variables(loaded_config: Dict[str, object]) -> None:
 
     global db_file_path, log_file_path, message_prefix, sent_message_prefix
     global notification_symbol, ack_implicit_str, ack_str, nak_str, ack_unknown_str
+    global node_list_16ths, channel_list_16ths
     global theme, COLOR_CONFIG
-    global node_sort
+    global node_sort, notification_sound
 
+    channel_list_16ths = loaded_config["channel_list_16ths"]
+    node_list_16ths = loaded_config["node_list_16ths"]
     db_file_path = loaded_config["db_file_path"]
     log_file_path = loaded_config["log_file_path"]
     message_prefix = loaded_config["message_prefix"]
     sent_message_prefix = loaded_config["sent_message_prefix"]
     notification_symbol = loaded_config["notification_symbol"]
+    notification_sound = loaded_config["notification_sound"]
     ack_implicit_str = loaded_config["ack_implicit_str"]
     ack_str = loaded_config["ack_str"]
     nak_str = loaded_config["nak_str"]
     ack_unknown_str = loaded_config["ack_unknown_str"]
+    node_sort = loaded_config["node_sort"]
     theme = loaded_config["theme"]
     if theme == "dark":
         COLOR_CONFIG = loaded_config["COLOR_CONFIG_DARK"]
@@ -189,7 +197,6 @@ def assign_config_variables(loaded_config: Dict[str, object]) -> None:
         COLOR_CONFIG = loaded_config["COLOR_CONFIG_LIGHT"]
     elif theme == "green":
         COLOR_CONFIG = loaded_config["COLOR_CONFIG_GREEN"]
-    node_sort = loaded_config["node_sort"]
 
 
 # Call the function when the script is imported

contact/ui/nav_utils.py

@@ -1,8 +1,22 @@
 import curses
 import re
+from unicodedata import east_asian_width
+
 from contact.ui.colors import get_color
 from contact.utilities.control_utils import transform_menu_path
 from typing import Any, Optional, List, Dict
+from contact.utilities.singleton import interface_state, ui_state
+
+
+def get_node_color(node_index: int, reverse: bool = False):
+    node_num = ui_state.node_list[node_index]
+    node = interface_state.interface.nodesByNum.get(node_num, {})
+    if node.get("isFavorite"):
+        return get_color("node_favorite", reverse=reverse)
+    elif node.get("isIgnored"):
+        return get_color("node_ignored", reverse=reverse)
+    return get_color("settings_default", reverse=reverse)
+
 
 # Aliases
 Segment = tuple[str, str, bool, bool]
@@ -128,7 +142,6 @@ def draw_arrows(
     win: object, visible_height: int, max_index: int, start_index: List[int], show_save_option: bool
 ) -> None:
 
-    # vh = visible_height + (1 if show_save_option else 0)
     mi = max_index - (2 if show_save_option else 0)
 
     if visible_height < mi:
@@ -282,9 +295,16 @@ def get_wrapped_help_text(
 
     return wrapped_help
 
+def text_width(text: str) -> int:
+    return sum(2 if east_asian_width(c) in "FW" else 1 for c in text)
 
 def wrap_text(text: str, wrap_width: int) -> List[str]:
     """Wraps text while preserving spaces and breaking long words."""
+
+    whitespace = '\t\n\x0b\x0c\r '
+    whitespace_trans = dict.fromkeys(map(ord, whitespace), ord(' '))
+    text = text.translate(whitespace_trans)
+
     words = re.findall(r"\S+|\s+", text)  # Capture words and spaces separately
     wrapped_lines = []
     line_buffer = ""
@@ -293,11 +313,11 @@ def wrap_text(text: str, wrap_width: int) -> List[str]:
     wrap_width -= margin
 
     for word in words:
-        word_length = len(word)
+        word_length = text_width(word)
 
         if word_length > wrap_width:  # Break long words
             if line_buffer:
-                wrapped_lines.append(line_buffer)
+                wrapped_lines.append(line_buffer.strip())
                 line_buffer = ""
                 line_length = 0
             for i in range(0, word_length, wrap_width):
@@ -305,7 +325,7 @@ def wrap_text(text: str, wrap_width: int) -> List[str]:
             continue
 
         if line_length + word_length > wrap_width and word.strip():
-            wrapped_lines.append(line_buffer)
+            wrapped_lines.append(line_buffer.strip())
             line_buffer = ""
             line_length = 0
 
@@ -313,6 +333,94 @@ def wrap_text(text: str, wrap_width: int) -> List[str]:
         line_length += word_length
 
     if line_buffer:
-        wrapped_lines.append(line_buffer)
+        wrapped_lines.append(line_buffer.strip())
 
     return wrapped_lines
+
+
+def move_main_highlight(
+    old_idx: int, new_idx, options: List[str], menu_win: curses.window, menu_pad: curses.window, ui_state: object
+) -> None:
+
+    if old_idx == new_idx:  # No-op
+        return
+
+    max_index = len(options) - 1
+    visible_height = menu_win.getmaxyx()[0] - 2
+
+    if new_idx < ui_state.start_index[ui_state.current_window]:  # Moving above the visible area
+        ui_state.start_index[ui_state.current_window] = new_idx
+    elif new_idx >= ui_state.start_index[ui_state.current_window] + visible_height:  # Moving below the visible area
+        ui_state.start_index[ui_state.current_window] = new_idx - visible_height + 1
+
+    # Ensure start_index is within bounds
+    ui_state.start_index[ui_state.current_window] = max(
+        0, min(ui_state.start_index[ui_state.current_window], max_index - visible_height + 1)
+    )
+
+    highlight_line(menu_win, menu_pad, old_idx, new_idx, visible_height)
+
+    if ui_state.current_window == 0:  # hack to fix max_index
+        max_index += 1
+
+    draw_main_arrows(menu_win, max_index, window=ui_state.current_window)
+    menu_win.refresh()
+
+
+def highlight_line(
+    menu_win: curses.window, menu_pad: curses.window, old_idx: int, new_idx: int, visible_height: int
+) -> None:
+
+    if ui_state.current_window == 0:
+        color_old = (
+            get_color("channel_selected") if old_idx == ui_state.selected_channel else get_color("channel_list")
+        )
+        color_new = get_color("channel_list", reverse=True) if True else get_color("channel_list", reverse=True)
+        menu_pad.chgat(old_idx, 1, menu_pad.getmaxyx()[1] - 4, color_old)
+        menu_pad.chgat(new_idx, 1, menu_pad.getmaxyx()[1] - 4, color_new)
+
+    elif ui_state.current_window == 2:
+        menu_pad.chgat(old_idx, 1, menu_pad.getmaxyx()[1] - 4, get_node_color(old_idx))
+        menu_pad.chgat(new_idx, 1, menu_pad.getmaxyx()[1] - 4, get_node_color(new_idx, reverse=True))
+
+    menu_win.refresh()
+
+    # Refresh pad only if scrolling is needed
+    menu_pad.refresh(
+        ui_state.start_index[ui_state.current_window],
+        0,
+        menu_win.getbegyx()[0] + 1,
+        menu_win.getbegyx()[1] + 1,
+        menu_win.getbegyx()[0] + visible_height,
+        menu_win.getbegyx()[1] + menu_win.getmaxyx()[1] - 3,
+    )
+
+
+def draw_main_arrows(win: object, max_index: int, window: int, **kwargs) -> None:
+
+    height, width = win.getmaxyx()
+    usable_height = height - 2
+    usable_width = width - 2
+
+    if window == 1 and ui_state.display_log:
+        if log_height := kwargs.get("log_height"):
+            usable_height -= log_height - 1
+
+    if usable_height < max_index:
+        if ui_state.start_index[window] > 0:
+            win.addstr(1, usable_width, "▲", get_color("settings_default"))
+        else:
+            win.addstr(1, usable_width, " ", get_color("settings_default"))
+
+        if max_index - ui_state.start_index[window] - 1 >= usable_height:
+            win.addstr(usable_height, usable_width, "▼", get_color("settings_default"))
+        else:
+            win.addstr(usable_height, usable_width, " ", get_color("settings_default"))
+    else:
+        win.addstr(1, usable_width, " ", get_color("settings_default"))
+        win.addstr(usable_height, usable_width, " ", get_color("settings_default"))
+
+
+def get_msg_window_lines(messages_win, packetlog_win) -> None:
+    packetlog_height = packetlog_win.getmaxyx()[0] - 1 if ui_state.display_log else 0
+    return messages_win.getmaxyx()[0] - 2 - packetlog_height

contact/ui/ui_state.py

@@ -25,6 +25,11 @@ class ChatUIState:
     selected_node: int = 0
     current_window: int = 0
 
+    selected_index: int = 0
+    start_index: List[int] = field(default_factory=lambda: [0, 0, 0])
+    show_save_option: bool = False
+    menu_path: List[str] = field(default_factory=list)
+
 
 @dataclass
 class InterfaceState:

contact/ui/user_config.py

@@ -55,10 +55,15 @@ def edit_value(key: str, current_value: str) -> str:
         # Load theme names dynamically from the JSON
         theme_options = [k.split("_", 2)[2].lower() for k in loaded_config.keys() if k.startswith("COLOR_CONFIG")]
         return get_list_input("Select Theme", current_value, theme_options)
+
     elif key == "node_sort":
         sort_options = ["lastHeard", "name", "hops"]
         return get_list_input("Sort By", current_value, sort_options)
 
+    elif key == "notification_sound":
+        sound_options = ["True", "False"]
+        return get_list_input("Notification Sound", current_value, sound_options)
+
     # Standard Input Mode (Scrollable)
     edit_win.addstr(7, 2, "New Value: ", get_color("settings_default"))
     curses.curs_set(1)

contact/utilities/config_io.py

@@ -1,5 +1,6 @@
 import yaml
 import logging
+import time
 from typing import List
 from google.protobuf.json_format import MessageToDict
 from meshtastic import mt_config
@@ -133,24 +134,29 @@ def config_import(interface, filename):
             logging.info(f"Setting device owner to {configuration['owner']}")
             waitForAckNak = True
             interface.getNode("^local", False).setOwner(configuration["owner"])
+            time.sleep(0.5)
 
         if "owner_short" in configuration:
             logging.info(f"Setting device owner short to {configuration['owner_short']}")
             waitForAckNak = True
             interface.getNode("^local", False).setOwner(long_name=None, short_name=configuration["owner_short"])
+            time.sleep(0.5)
 
         if "ownerShort" in configuration:
             logging.info(f"Setting device owner short to {configuration['ownerShort']}")
             waitForAckNak = True
             interface.getNode("^local", False).setOwner(long_name=None, short_name=configuration["ownerShort"])
+            time.sleep(0.5)
 
         if "channel_url" in configuration:
             logging.info(f"Setting channel url to {configuration['channel_url']}")
             interface.getNode("^local").setURL(configuration["channel_url"])
+            time.sleep(0.5)
 
         if "channelUrl" in configuration:
             logging.info(f"Setting channel url to {configuration['channelUrl']}")
             interface.getNode("^local").setURL(configuration["channelUrl"])
+            time.sleep(0.5)
 
         if "location" in configuration:
             alt = 0
@@ -169,12 +175,14 @@ def config_import(interface, filename):
                 logging.info(f"Fixing longitude at {lon} degrees")
             logging.info("Setting device position")
             interface.localNode.setFixedPosition(lat, lon, alt)
+            time.sleep(0.5)
 
         if "config" in configuration:
             localConfig = interface.getNode("^local").localConfig
             for section in configuration["config"]:
                 traverseConfig(section, configuration["config"][section], localConfig)
                 interface.getNode("^local").writeConfig(camel_to_snake(section))
+                time.sleep(0.5)
 
         if "module_config" in configuration:
             moduleConfig = interface.getNode("^local").moduleConfig
@@ -185,6 +193,7 @@ def config_import(interface, filename):
                     moduleConfig,
                 )
                 interface.getNode("^local").writeConfig(camel_to_snake(section))
+                time.sleep(0.5)
 
         interface.getNode("^local", False).commitSettingsTransaction()
         logging.info("Writing modified configuration to device")

contact/utilities/input_handlers.py

@@ -104,11 +104,13 @@ def get_admin_key_input(current_value: List[bytes]) -> Optional[List[str]]:
         return [base64.b64encode(b).decode() for b in byte_strings]
 
     def is_valid_base64(s):
-        """Check if a string is valid Base64."""
+        """Check if a string is valid Base64 or blank."""
+        if s == "":
+            return True
         try:
             decoded = base64.b64decode(s, validate=True)
             return len(decoded) == 32  # Ensure it's exactly 32 bytes
-        except binascii.Error:
+        except (binascii.Error, ValueError):
             return False
 
     cvalue = to_base64(current_value)  # Convert current values to Base64

contact/utilities/utils.py

@@ -1,4 +1,5 @@
 import datetime
+import time
 from meshtastic.protobuf import config_pb2
 import contact.ui.default_config as config
 
@@ -134,3 +135,31 @@ def get_time_ago(timestamp):
     if unit != "s":
         return f"{value} {unit} ago"
     return "now"
+
+def add_new_message(channel_id, prefix, message):
+    if channel_id not in ui_state.all_messages:
+        ui_state.all_messages[channel_id] = []
+
+    # Timestamp handling
+    current_timestamp = time.time()
+    current_hour = datetime.datetime.fromtimestamp(current_timestamp).strftime("%Y-%m-%d %H:00")
+
+    # Retrieve the last timestamp if available
+    channel_messages = ui_state.all_messages[channel_id]
+    if channel_messages:
+        # Check the last entry for a timestamp
+        for entry in reversed(channel_messages):
+            if entry[0].startswith("--"):
+                last_hour = entry[0].strip("- ").strip()
+                break
+        else:
+            last_hour = None
+    else:
+        last_hour = None
+
+    # Add a new timestamp if it's a new hour
+    if last_hour != current_hour:
+        ui_state.all_messages[channel_id].append((f"-- {current_hour} --", ""))
+
+    # Add the message
+    ui_state.all_messages[channel_id].append((prefix,message))

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "contact"
-version = "1.3.8"
+version = "1.3.15"
 description = "This Python curses client for Meshtastic is a terminal-based client designed to manage device settings, enable mesh chat communication, and handle configuration backups and restores."
 authors = [
     {name = "Ben Lipsey",email = "ben@pdxlocations.com"}