listpick 0.1.15.19__py3-none-any.whl → 0.1.16.17__py3-none-any.whl

listpick/listpick_app.py

@@ -18,12 +18,15 @@ from wcwidth import wcswidth
 from typing import Callable, Optional, Tuple, Dict
 import json
 import threading
+import multiprocessing
 import string
 import logging
-import tty
-import select
+import copy
+import tempfile
+import queue
 
 from listpick.pane.pane_utils import get_file_attributes
+from listpick.pane.left_pane_functions import *
 from listpick.ui.picker_colours import get_colours, get_help_colours, get_notification_colours, get_theme_count, get_fallback_colours
 from listpick.utils.options_selectors import default_option_input, output_file_option_selector, default_option_selector
 from listpick.utils.table_to_list_of_lists import *
@@ -36,24 +39,20 @@ from listpick.utils.paste_operations import *
 from listpick.utils.searching import search
 from listpick.ui.help_screen import help_lines
 from listpick.ui.keys import picker_keys, notification_keys, options_keys, help_keys
-from listpick.utils.generate_data import generate_picker_data
+from listpick.utils.generate_data_multithreaded import generate_picker_data_from_file
 from listpick.utils.dump import dump_state, load_state, dump_data
 from listpick.ui.build_help import build_help_rows
 from listpick.ui.footer import StandardFooter, CompactFooter, NoFooter
 from listpick.utils.picker_log import setup_logger
-from listpick.utils.user_input import get_char, open_tty
-from listpick.pane.pane_functions import right_split_file_attributes, right_split_graph, right_split_display_list
+from listpick.utils.user_input import get_char, open_tty, restore_terminal_settings
+from listpick.pane.pane_functions import right_split_file_attributes, right_split_file_attributes_dynamic, right_split_graph, right_split_display_list
 from listpick.pane.get_data import *
 
-
-try:
-    from tmp.data_stuff import test_items, test_highlights, test_header
-except:
-    test_items, test_highlights, test_header = [], [], []
-
 COLOURS_SET = False
 help_colours, notification_colours = {}, {}
 
+os.environ["TMPDIR"] = "/tmp"
+
 class Command:
     def __init__(self, command_type, command_value):
         self.command_type = command_type
@@ -64,7 +63,7 @@ class Picker:
         stdscr: curses.window, 
         items: list[list[str]] = [],
         cursor_pos: int = 0,
-        colours: dict = get_colours(0),
+        colours: dict = {},
         colour_theme_number: int = 3,
         max_selected: int = -1,
         top_gap: int =0,
@@ -76,9 +75,9 @@ class Picker:
         auto_refresh: bool =False,
         timer: float = 5,
 
-        get_new_data: bool =False,                          # Whether we can get new data
-        refresh_function: Optional[Callable] = lambda: [],  # The function with which we get new data
-        get_data_startup: bool =False,                      # Whether we should get data at statrup
+        get_new_data: bool =False,
+        refresh_function: Optional[Callable] = lambda items, header, visible_rows_indices, getting_data: None,
+        get_data_startup: bool =False,
         track_entries_upon_refresh: bool = True,
         pin_cursor: bool = False,
         id_column: int = 0,
@@ -101,7 +100,12 @@ class Picker:
         user_opts : str = "",
         options_list: list[str] = [],
         user_settings : str = "",
+
         separator : str = "    ",
+        header_separator : str = "   │",
+        header_separator_before_selected_column : str = "   ▐",
+
+        
         search_query : str = "",
         search_count : int = 0,
         search_index : int = 0,
@@ -116,6 +120,10 @@ class Picker:
         highlight_full_row: bool =False,
         crosshair_cursor: bool = False,
         cell_cursor: bool = True,
+        selected_char: str = "",
+        unselected_char: str = "",
+        selecting_char: str = "",
+        deselecting_char: str = "",
 
         items_per_page : int = -1,
         sort_method : int = 0,
@@ -127,17 +135,18 @@ class Picker:
         columns_sort_method: list[int] = [0],
         key_chain: str = "",
         last_key: Optional[str] = None,
+        disabled_keys: list=[],
 
         paginate: bool =False,
         cancel_is_back: bool = False,
         mode_index: int = 0,
         modes: list[dict] = [],
-        display_modes: bool =False,
-        require_option: list=[],
-        require_option_default: list=[],
+        display_modes: bool = False,
+        require_option: list[bool] = [],
+        require_option_default: bool = False,
         option_functions: list[Callable[..., Tuple[bool, str]]] = [],
         default_option_function: Callable[..., Tuple[bool, str]] = default_option_input,
-        disabled_keys: list=[],
+
 
         show_header: bool = True,
         show_row_header: bool = False,
@@ -145,7 +154,7 @@ class Picker:
         footer_style: int = 0,
         footer_string: str="",
         footer_string_auto_refresh: bool=False,
-        footer_string_refresh_function: Optional[Callable] = None,
+        footer_string_refresh_function: Optional[Callable] = lambda : None,
         footer_timer: float=1,
         get_footer_string_startup=False,
         unicode_char_width: bool = True,
@@ -155,6 +164,7 @@ class Picker:
         reset_colours: bool = True,
         key_remappings: dict = {},
         keys_dict:dict = picker_keys,
+        macros: list = [],
         display_infobox : bool = False,
         infobox_items: list[list[str]] = [],
         infobox_title: str = "",
@@ -195,11 +205,24 @@ class Picker:
         split_right: bool = False,
         right_panes: list = [],
         right_pane_index: int = 0,
+
+        split_left: bool = False,
+        left_panes: list = [],
+        left_pane_index: int = 0,
+
+        screen_size_function = lambda stdscr: os.get_terminal_size()[::-1],
+        generate_data_for_hidden_columns: bool = False,
+
+
+        # getting_data: threading.Event = threading.Event(),
+
     ):
+
+        self.screen_size_function = screen_size_function
         self.stdscr = stdscr
         self.items = items
         self.cursor_pos = cursor_pos
-        self.colours = colours
+        self.colours = get_colours(colour_theme_number)
         self.colour_theme_number = colour_theme_number
         self.max_selected = max_selected
         self.top_gap = top_gap
@@ -237,6 +260,8 @@ class Picker:
         self.options_list = options_list
         self.user_settings = user_settings
         self.separator = separator
+        self.header_separator = header_separator
+        self.header_separator_before_selected_column = header_separator_before_selected_column
         self.search_query = search_query
         self.search_count = search_count
         self.search_index = search_index
@@ -251,6 +276,10 @@ class Picker:
         self.highlight_full_row = highlight_full_row
         self.crosshair_cursor = crosshair_cursor
         self.cell_cursor = cell_cursor
+        self.selected_char = selected_char
+        self.unselected_char = unselected_char
+        self.selecting_char = selecting_char
+        self.deselecting_char = deselecting_char
 
         self.items_per_page = items_per_page
         self.sort_method = sort_method
@@ -280,7 +309,7 @@ class Picker:
         self.footer_string_auto_refresh = footer_string_auto_refresh
         self.footer_string_refresh_function = footer_string_refresh_function
         self.footer_timer = footer_timer
-        self.get_footer_string_startup = get_footer_string_startup,
+        self.get_footer_string_startup = get_footer_string_startup
         self.unicode_char_width = unicode_char_width
 
 
@@ -289,6 +318,7 @@ class Picker:
         self.reset_colours = reset_colours
         self.key_remappings = key_remappings
         self.keys_dict = keys_dict
+        self.macros = macros
         self.display_infobox = display_infobox
         self.infobox_items = infobox_items
         self.infobox_title = infobox_title
@@ -312,7 +342,6 @@ class Picker:
 
 
         # Refresh function variables
-        self.data_refreshed = False
         self.refreshing_data = False
         self.data_lock = threading.Lock()
         self.data_ready = False
@@ -347,14 +376,45 @@ class Picker:
         self.split_right = split_right
         self.right_panes = right_panes
         self.right_pane_index = right_pane_index
+
+        self.split_left = split_left
+        self.left_panes = left_panes
+        self.left_pane_index = left_pane_index
+
+        self.visible_rows_indices = []
+
+        self.generate_data_for_hidden_columns = generate_data_for_hidden_columns
+        self.thread_stop_event = threading.Event()
+        self.data_generation_queue = queue.PriorityQueue()
+        self.threads = []
+
+
+        self.process_manager = multiprocessing.Manager()
+        # self.data_generation_queue = ProcessSafePriorityQueue
+        self.processes = []
+        self.items_sync_loop_event = threading.Event() 
+        self.items_sync_thread = None
+
+
         self.initialise_picker_state(reset_colours=self.reset_colours)
 
         # Note: We have to set the footer after initialising the picker state so that the footer can use the get_function_data method
         self.footer_options = [StandardFooter(self.stdscr, colours_start, self.get_function_data), CompactFooter(self.stdscr, colours_start, self.get_function_data), NoFooter(self.stdscr, colours_start, self.get_function_data)]
         self.footer = self.footer_options[self.footer_style]
-        self.__version__ = "1.0"
+        self.footer.adjust_sizes(self.term_h, self.term_w)
+
+
+
+        # getting_data.is_set() is True when we are getting data
+        self.getting_data = threading.Event()
+        self.getting_data.set()
 
     def __sizeof__(self):
+        """
+        Return the approximate memory footprint of the Picker instance.
+
+        This includes the size of the instance itself and the sizes of its attributes.
+        """
 
         size = super().__sizeof__()
         
@@ -365,7 +425,19 @@ class Picker:
         return size
     
     def set_config(self, path: str ="~/.config/listpick/config.toml") -> bool:
-        """ Set config from toml file. """
+        """ Set config from toml file.
+
+        This method reads a configuration file in TOML format, applies settings 
+        to the Picker, and returns a boolean indicating success or failure.
+
+        Args:
+            path (str): The path to the configuration file.
+
+        Returns:
+            bool: True if the configuration was successfully set; False otherwise.
+        """
+        self.logger.info(f"function: set_config()")
+
         path = os.path.expanduser(os.path.expandvars(path))
         if not os.path.exists(path):
             return False
@@ -374,14 +446,17 @@ class Picker:
         except Exception as e:
             self.logger.error(f"get_config({path}) load error. {e}")
             return False
+        
 
+        # Change the global theme if colour_theme_number is in the loaded config
         if "general" in config:
             if "colour_theme_number" in config["general"] and config["general"]["colour_theme_number"] != self.colour_theme_number:
                 global COLOURS_SET 
                 COLOURS_SET = False
                 self.colours_end = set_colours(pick=config["general"]["colour_theme_number"], start=1)
+                self.colours = get_colours(config["general"]["colour_theme_number"])
 
-        self.logger.info(f"function: set_config()")
+        # load the rest of the config options
         if "general" in config:
             for key, val in config["general"].items():
                 self.logger.info(f"set_config: key={key}, val={val}.")
@@ -393,19 +468,58 @@ class Picker:
         return True
 
     def get_config(self, path: str ="~/.config/listpick/config.toml") -> dict:
-        """ Get config from file. """
+        """ 
+        Retrieve configuration settings from a specified TOML file.
+
+        Args:
+            path (str): The file path of the configuration file. Default is 
+            ~/.config/listpick/config.toml.
+
+        Returns:
+            dict: A dictionary containing the configuration settings loaded
+            from the TOML file. In case of an error, an empty dictionary is returned.
+        """
+
         self.logger.info(f"function: get_config()")
         import toml
         with open(os.path.expanduser(path), "r") as f:
             config = toml.load(f)
             return config
 
-    def calculate_section_sizes(self):
+    def update_term_size(self) -> None:
+        """
+        Update self.term_h, self.term_w the function provided to the Picker.
+
+        Returns:
+            None
+        """
+        self.term_h, self.term_w = self.screen_size_function(self.stdscr)
+        # self.term_h, self.term_w = self.stdscr.getmaxyx()
+        # self.term_w, self.term_h = os.get_terminal_size()
+
+
+    def get_term_size(self) -> Tuple[int, int]:
+        """
+        Get the current terminal size using the function provided to the Picker.
+
+        Returns:
+            Tuple[int, int]: A tuple containing the (height, width) of the terminal.
+        """
+        return self.screen_size_function(self.stdscr)
+        # return self.stdscr.getmaxyx()
+        # w, h = os.get_terminal_size()
+        # return h, w
+
+    def calculate_section_sizes(self) -> None:
         """
         Calculte the following for the Picker:
         self.items_per_page: the number of entry rows displayed
         self.bottom_space: the size of the footer + the bottom buffer space
         self.top_space: the size of the space at the top of the picker: title + modes + header + top_gap
+        Calculate and update the sizes of various sections of the Picker.
+
+        Returns:
+            None
         """
 
         self.logger.debug(f"function: calculate_section_sizes()")
@@ -413,14 +527,35 @@ class Picker:
         # self.bottom_space
         self.bottom_space = self.footer.height if self.show_footer else 0
 
+        # self.left_gutter_width
+        self.left_gutter_width = 1 if self.highlight_full_row else 2
+        if self.show_row_header: self.left_gutter_width += len(str(len(self.items))) + 2
+
+
         ## self.top_space
-        h, w = self.stdscr.getmaxyx()
-        self.term_h, self.term_w = self.stdscr.getmaxyx()
+        self.update_term_size()
+        self.rows_w, self.rows_h = self.term_w, self.term_h
+        self.rows_box_x_i = 0
+        self.rows_box_x_f = self.term_w
+        self.left_pane_width = self.right_pane_width = 0
         if self.split_right and len(self.right_panes):
             proportion = self.right_panes[self.right_pane_index]["proportion"]
-            self.rows_w, self.rows_h = int(self.term_w*proportion), self.term_h
-        else:
-            self.rows_w, self.rows_h = self.term_w, self.term_h
+            self.right_pane_width = int(self.term_w*proportion)
+            self.rows_w -= self.right_pane_width
+            self.rows_box_x_f -= self.right_pane_width
+        if self.split_left and len(self.left_panes):
+            proportion = self.left_panes[self.left_pane_index]["proportion"]
+            self.left_pane_width = int(self.term_w*proportion)
+            self.rows_w -= self.left_pane_width
+            self.rows_box_x_i += self.left_pane_width
+        if self.left_pane_width + self.right_pane_width >= self.term_w-3:
+            self.rows_w += 10
+            self.left_pane_width -= 5
+            self.right_pane_width -= 5
+            self.rows_box_x_i -= 5
+            self.rows_box_x_f += 5
+
+
 
         self.top_space = self.top_gap
         if self.title: self.top_space+=1
@@ -438,42 +573,66 @@ class Picker:
             self.top_space += ((self.term_h-(self.top_space+self.bottom_space))-len(self.indexed_items))//2
 
         # self.column_widths
-        visible_column_widths = [c for i,c in enumerate(self.column_widths) if i not in self.hidden_columns]
-        visible_columns_total_width = sum(visible_column_widths) + len(self.separator)*(len(visible_column_widths)-1)
+        self.visible_column_widths = [c for i,c in enumerate(self.column_widths) if i not in self.hidden_columns]
+        visible_columns_total_width = sum(self.visible_column_widths) + len(self.separator)*(len(self.visible_column_widths)-1)
 
         # self.startx
         self.startx = 1 if self.highlight_full_row else 2
         if self.show_row_header: self.startx += len(str(len(self.items))) + 2
         if visible_columns_total_width < self.rows_w and self.centre_in_terminal:
             self.startx += (self.rows_w - visible_columns_total_width) // 2
+        self.startx += self.left_pane_width
+        # if self.split_left and len(self.left_panes):
+        #     proportion = self.left_panes[self.left_pane_index]["proportion"]
+        #     self.startx += int(self.term_w*proportion)
+
+        self.endx = self.startx+self.rows_w
+
+
 
     def get_visible_rows(self) -> list[list[str]]:
+        """
+        Calculate and return the currently visible rows based on the cursor position and pagination settings.
+
+        This method determines which rows from the indexed items are visible on the screen,
+        accounting for pagination and scrolling. It sets the starting and ending indices
+        based on the current cursor position and the number of items per page.
 
+        Returns:
+            list[list[str]]: The currently visible rows as a list of lists, where each inner
+            list represents a row of data. If there are no indexed items, it returns the
+            items array.
+        """
         self.logger.debug(f"function: get_visible_rows()")
         ## Scroll with column select
         if self.paginate:
-            start_index = (self.cursor_pos//self.items_per_page) * self.items_per_page
+            start_index = (self.cursor_pos // self.items_per_page) * self.items_per_page
             end_index = min(start_index + self.items_per_page, len(self.indexed_items))
         ## Scroll
         else:
-            scrolloff = self.items_per_page//2
-            start_index = max(0, min(self.cursor_pos - (self.items_per_page-scrolloff), len(self.indexed_items)-self.items_per_page))
+            scrolloff = self.items_per_page // 2
+            start_index = max(0, min(self.cursor_pos - (self.items_per_page - scrolloff), len(self.indexed_items) - self.items_per_page))
             end_index = min(start_index + self.items_per_page, len(self.indexed_items))
         if len(self.indexed_items) == 0: start_index, end_index = 0, 0
 
-        rows = [v[1] for v in self.indexed_items[start_index:end_index]] if len(self.indexed_items) else self.items
-        return rows
+        self.visible_rows = [v[1] for v in self.indexed_items[start_index:end_index]] if len(self.indexed_items) else self.items
+        # self.visible_rows_indices = [v[0] for v in self.indexed_items[start_index:end_index]] if len(self.indexed_items) else []
+        self.visible_rows_indices.clear()
+        self.visible_rows_indices.extend([v[0] for v in self.indexed_items[start_index:end_index]])
+        return self.visible_rows
 
     def initialise_picker_state(self, reset_colours=False) -> None:
         """ Initialise state variables for the picker. These are: debugging and colours. """
 
+        # Define global curses colours
         if curses.has_colors() and self.colours != None:
-            # raise Exception("Terminal does not support color")
             curses.start_color()
+
             if reset_colours:
                 global COLOURS_SET
                 COLOURS_SET = False
                 self.colours_end = set_colours(pick=self.colour_theme_number, start=self.colours_start)
+
             if curses.COLORS >= 255 and curses.COLOR_PAIRS >= 150:
                 self.colours_start = self.colours_start
                 self.notification_colours_start = self.colours_start+50
@@ -487,64 +646,43 @@ class Picker:
                 self.notification_colours_start = 0
                 self.help_colours_start = 0
 
+        self.colours = get_colours(self.colour_theme_number)
+
 
+        # Start logger
         debug_levels = [logging.DEBUG, logging.INFO, logging.WARNING, logging.ERROR, logging.CRITICAL]
         dbglvl =  debug_levels[self.debug_level]
         self.logger = setup_logger(name="picker_log", log_file="picker.log", log_enabled=self.debug, level =dbglvl)
         self.logger.info(f"Initialiasing Picker.")
-        # self.notification(self.stdscr, message=repr(self.logger))
-
-
-        #                     1              2             3                4              5
-        # logger = logging.getLogger(__file__)
-        # if self.debug_level == 0:
-        #     logger = logging.getLogger()
-        #     logger.disabled = True
-        # else:
-        #
-        #     file_handler = logging.FileHandler(f"{self.title}.log", mode='w')
-        #     formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s', '%m-%d-%Y %H:%M:%S')
-        #     file_handler.setFormatter(formatter)
-        #     logger.addHandler(file_handler)
-        #     logger.setLevel(debug_levels[self.debug_level-1])
-
-            # logging.basicConfig(
-            #     level=debug_levels[self.debug_level-1],
-            #     format='%(asctime)s - %(levelname)s - %(message)s',
-            #     datefmt='%m-%d-%Y %H:%M:%S',
-            #     filename=f"{self.title}.log",
-            #     filemode="w",
-            # )
-        #
-        # self.logger.info(f"Starging log. Log level {logger.getEffectiveLevel()}")
-        # self.logger.info(f"Starging log. Log level {repr(debug_levels)}, {self.debug_level}, {debug_levels[self.debug_level-1]}")
-        # self.notification(self.stdscr, f"Starging log. Log level {repr(debug_levels)}, {self.debug_level}, {debug_levels[self.debug_level-1]}")
-        # self.notification(self.stdscr, f"{__file__}")
-
-        ## Logging level plan
-        # DEBUG: loop functions, draw screen, etc.
-        # INFO: main functions 
-        # WARNING: any try-except fails 
-
-        # No set_escdelay function on windows.
+
+        self.update_term_size()
+
+        # The curses implementation for some systems (e.g., windows) does not allow set_escdelay
         try:
             curses.set_escdelay(25)
         except:
             logging.warning("Error trying to set curses.set_escdelay")
 
-        # self.stdscr.clear()
-        # self.stdscr.refresh()
-        # self.draw_screen(self.indexed_items, self.highlights)
-
     def initialise_variables(self, get_data: bool = False) -> None:
-        """ Initialise the variables that keep track of the data. """
+        """
+        This method sets up the internal state of the Picker by initialising various attributes,
+        getting new data (if get_data is True), and ensuring that the lists used for tracking 
+        selections, options, and items are correctly of the correct type, size, and shape. If 
+        filter or sort queries are set then they are applied (or re-applied as the case may be).
+        The cursor_pos and selections are retained by tracking the id of the rows (where the id 
+        is row[self.id_column]). 
+
+        Parameters:
+        - get_data (bool): If True, pulls data synchronously and updates tracking variables.
+        """
 
         self.logger.info(f"function: initialise_variables()")
 
         tracking = False
 
         ## Get data synchronously
-        if get_data and self.refresh_function != None:
+        if get_data:
+            # Track cursor_pos and selections by ther id (row[self.id_column][col])
             if self.track_entries_upon_refresh and len(self.items) > 0:
                 tracking = True
                 selected_indices = get_selected_indices(self.selections)
@@ -552,31 +690,41 @@ class Picker:
                 self.ids = [item[self.id_column] for i, item in enumerate(self.items) if i in selected_indices]
                 self.ids_tuples = [(i, item[self.id_column]) for i, item in enumerate(self.items) if i in selected_indices]
         
-                if len(self.indexed_items) > 0 and len(self.indexed_items) >= self.cursor_pos and len(self.indexed_items[0][1]) >= self.id_column:
+                if len(self.indexed_items) > 0 and self.cursor_pos < len(self.indexed_items) and len(self.indexed_items[0][1]) >= self.id_column:
                     self.cursor_pos_id = self.indexed_items[self.cursor_pos][1][self.id_column]
                     self.cursor_pos_prev = self.cursor_pos
-        
-            self.items, self.header = self.refresh_function()
 
-        self.items = pad_lists_to_same_length(self.items)
+            # Set the state of the threading event
+            # Though we are getting data synchronously, we ensure the correct state for self.getting_data 
+            self.getting_data.clear()
+            self.refresh_function(
+                self.items,
+                self.header,
+                self.visible_rows_indices,
+                self.getting_data,
+                self.get_function_data(),
+            )
+
                     
+        # Ensure that an emtpy items object has the form [[]]
         if self.items == []: self.items = [[]]
-        ## Ensure that items is a List[List[Str]] object
+
+        # Ensure that items is a List[List[Str]] object
         if len(self.items) > 0 and not isinstance(self.items[0], list):
             self.items = [[item] for item in self.items]
-        self.items = [[str(cell) for cell in row] for row in self.items]
+        # self.items = [[str(cell) for cell in row] for row in self.items]
 
+        # Ensure that the each of the rows of the items are of the same length
+        self.items = pad_lists_to_same_length(self.items)
 
         # Ensure that header is of the same length as the rows
         if self.header and len(self.items) > 0 and len(self.header) != len(self.items[0]):
             self.header = [str(self.header[i]) if i < len(self.header) else "" for i in range(len(self.items[0]))]
 
-        # Constants
-        # DEFAULT_ITEMS_PER_PAGE = os.get_terminal_size().lines - top_gap*2-2-int(bool(header))
-
         self.calculate_section_sizes()
 
-        # Initial states
+
+        # Ensure that the selection-tracking variables are the correct shape
         if len(self.selections) != len(self.items):
             self.selections = {i : False if i not in self.selections else bool(self.selections[i]) for i in range(len(self.items))}
 
@@ -587,31 +735,34 @@ class Picker:
             self.cell_selections = {}
             self.selected_cells_by_row = {}
 
+        def extend_list_to_length(lst, length, default_value):
+            """Extend a list to the target length using a default value."""
+            if len(lst) < length:
+                lst.extend([copy.deepcopy(default_value) for _ in range(length - len(lst))])
         
 
-        if len(self.require_option) < len(self.items):
-            self.require_option += [self.require_option_default for i in range(len(self.items)-len(self.require_option))]
-        if len(self.option_functions) < len(self.items):
-            self.option_functions += [self.default_option_function for i in range(len(self.items)-len(self.option_functions))]
-        if len(self.items)>0 and len(self.columns_sort_method) < len(self.items[0]):
-            self.columns_sort_method = self.columns_sort_method + [0 for i in range(len(self.items[0])-len(self.columns_sort_method))]
-        if len(self.items)>0 and len(self.sort_reverse) < len(self.items[0]):
-            self.sort_reverse = self.sort_reverse + [False for i in range(len(self.items[0])-len(self.sort_reverse))]
-        if len(self.items)>0 and len(self.editable_columns) < len(self.items[0]):
-            self.editable_columns = self.editable_columns + [self.editable_by_default for i in range(len(self.items[0])-len(self.editable_columns))]
-        if len(self.items)>0 and len(self.column_indices) < len(self.items[0]):
+        row_count = len(self.items)
+        col_count = len(self.items[0]) if row_count else 0
+
+        # Ensure that the length of the option lists are of the correct length.
+        if row_count > 0:
+            extend_list_to_length(self.require_option, length=row_count, default_value=self.require_option_default)
+            extend_list_to_length(self.option_functions, length=row_count, default_value=self.default_option_function)
+            extend_list_to_length(self.columns_sort_method, length=col_count, default_value=0)
+            extend_list_to_length(self.sort_reverse, length=col_count, default_value=False)
+            extend_list_to_length(self.editable_columns, length=col_count, default_value=self.editable_by_default)
+
+        if row_count > 0 and len(self.column_indices) < len(self.items[0]):
             self.column_indices = self.column_indices + [i for i in range(len(self.column_indices), len(self.items[0]))]
 
 
         
-        # items2 = [[row[self.column_indices[i]] for i in range(len(row))] for row in self.items]
-        # self.indexed_items = list(enumerate(items2))
+        # Create an indexed list of the items which will track the visible rows
         if self.items == [[]]: self.indexed_items = []
         else: self.indexed_items = list(enumerate(self.items))
 
-        # If a filter is passed then refilter
+        # Apply the filter query
         if self.filter_query:
-            # prev_index = self.indexed_items[cursor_pos][0] if len(self.indexed_items)>0 else 0
             # prev_index = self.indexed_items[cursor_pos][0] if len(self.indexed_items)>0 else 0
             self.indexed_items = filter_items(self.items, self.indexed_items, self.filter_query)
             if self.cursor_pos in [x[0] for x in self.indexed_items]: self.cursor_pos = [x[0] for x in self.indexed_items].index(self.cursor_pos)
@@ -627,22 +778,30 @@ class Picker:
             )
             if return_val:
                 self.cursor_pos, self.search_index, self.search_count, self.highlights = tmp_cursor, tmp_index, tmp_count, tmp_highlights
-        # If a sort is passed
+
+        # Apply the current sort method
         if len(self.indexed_items) > 0:
             sort_items(self.indexed_items, sort_method=self.columns_sort_method[self.sort_column], sort_column=self.sort_column, sort_reverse=self.sort_reverse[self.sort_column])  # Re-sort self.items based on new column
 
 
-        # Adjust variables to ensure correctness if errors
-        ## Move to a selectable row (if applicable)
+        # If we have more unselectable indices than rows, clear the unselectable_indices
         if len(self.items) <= len(self.unselectable_indices): self.unselectable_indices = []
-        new_pos = (self.cursor_pos)%len(self.items)
-        while new_pos in self.unselectable_indices and new_pos != self.cursor_pos:
-            new_pos = (new_pos + 1) % len(self.items)
 
-        assert new_pos < len(self.items)
-        self.cursor_pos = new_pos
+        # Move cursur to a selectable row if we are currently on an unselectable row)
+        if self.cursor_pos * len(self.items) in self.unselectable_indices:
+            original_pos = new_pos = (self.cursor_pos)%len(self.items)
+            while new_pos in self.unselectable_indices:
+                new_pos = (new_pos + 1) % len(self.items)
+
+                # Break if we loop back to the original position
+                if new_pos == original_pos:
+                    break
+
+            self.cursor_pos = max(0, min(new_pos, len(self.items)-1))
+
+        # Initialise sheets
+        extend_list_to_length(self.sheet_states, length=len(self.sheets), default_value={})
 
-        # Sheets and files
         if len(self.sheet_states) < len(self.sheets):
             self.sheet_states += [{} for _ in range(len(self.sheets) - len(self.sheet_states))]
         if len(self.sheets):
@@ -650,15 +809,16 @@ class Picker:
                 self.sheet_index = 0
             self.sheet_name = self.sheets[self.sheet_index]
 
-        if len(self.loaded_file_states) < len(self.loaded_files):
-            self.loaded_file_states += [{} for _ in range(len(self.loaded_files) - len(self.loaded_file_states))]
+        # Initialise files
+        extend_list_to_length(self.loaded_file_states, length=len(self.loaded_files), default_value={})
         if len(self.loaded_files):
             if self.loaded_file_index >= len(self.loaded_files):
                 self.loaded_file_index = 0
             self.loaded_file = self.loaded_files[self.loaded_file_index]
 
-        # if tracking and len(self.items) > 1:
-        # Ensure that selected indices are tracked upon data refresh
+
+        # Ensure that the correct cursor_pos and selected indices are reselected
+        #   if  we have fetched new data.
         if self.track_entries_upon_refresh and (self.data_ready or tracking) and len(self.items) > 1:
             selected_indices = []
             all_ids = [item[self.id_column] for item in self.items]
@@ -681,6 +841,8 @@ class Picker:
 
 
 
+            # Ensure cursor_pos is set to a valid index
+            # If we have fetched new data then we attempt to set cursor_pos to the row with the same id as prev
             if len(self.indexed_items):
                 if self.pin_cursor:
                     self.cursor_pos = min(self.cursor_pos_prev, len(self.indexed_items)-1)
@@ -692,7 +854,12 @@ class Picker:
             else:
                 self.cursor_pos = 0
 
-        self.right_pane_index = max(0, min(self.right_pane_index, len(self.right_panes)-1))
+
+        # Ensure that the pane indices are within the range of the available panes.
+        if len(self.left_panes): self.left_pane_index %= len(self.left_panes)
+        else: self.left_pane_index = 0
+        if len(self.right_panes): self.right_pane_index %= len(self.right_panes)
+        else: self.right_pane_index = 0
         
 
 
@@ -739,13 +906,13 @@ class Picker:
 
         """
         self.logger.debug("function: test_screen_size()")
-        h, w = self.stdscr.getmaxyx()
+        self.update_term_size()
         ## Terminal too small to display Picker
-        if h<3 or w<len("Terminal"): return False
-        if (self.show_footer or self.footer_string) and (h<12 or w<35) or (h<12 and w<10):
-            self.stdscr.addstr(h//2-1, (w-len("Terminal"))//2, "Terminal")
-            self.stdscr.addstr(h//2, (w-len("Too"))//2, "Too")
-            self.stdscr.addstr(h//2+1, (w-len("Small"))//2, "Small")
+        if self.term_h<3 or self.term_w<len("Terminal"): return False
+        if (self.show_footer or self.footer_string) and (self.term_h<12 or self.term_w<35) or (self.term_h<12 and self.term_w<10):
+            self.stdscr.addstr(self.term_h//2-1, (self.term_w-len("Terminal"))//2, "Terminal")
+            self.stdscr.addstr(self.term_h//2, (self.term_w-len("Too"))//2, "Too")
+            self.stdscr.addstr(self.term_h//2+1, (self.term_w-len("Small"))//2, "Small")
             return False
         return True
 
@@ -758,28 +925,29 @@ class Picker:
 
         if type(message) == type(""): message = [message]
 
-        h, w =self.stdscr.getmaxyx()
-        if len(message) > h: start_y = 0
-        else: start_y = (h-len(message))//2
+        self.update_term_size()
+        if len(message) > self.term_h: start_y = 0
+        else: start_y = (self.term_h-len(message))//2
 
         for i in range(len(message)):
             try:
                 s = message[i]
-                if len(s) > w: s = s[:w-2]
-                self.stdscr.addstr(start_y+i, (w-len(s))//2, s, curses.color_pair(2))
+                if len(s) > self.term_w: s = s[:self.term_w-2]
+                self.stdscr.addstr(start_y+i, (self.term_w-len(s))//2, s, curses.color_pair(2))
             except:
                 pass
         self.stdscr.refresh()
 
-    def draw_screen(self, indexed_items: list[Tuple[int, list[str]]], highlights: list[dict] = [{}], clear: bool = True) -> None:
+    def draw_screen(self, clear: bool = True) -> None:
         """ Try-except wrapper for the draw_screen_ function. """
         try:
-            self.draw_screen_(self.indexed_items, self.highlights)
+            self.draw_screen_(clear)
         except Exception as e:
             self.logger.warning(f"self.draw_screen_() error. {e}")
-            pass
+        finally:
+            self.stdscr.refresh()
 
-    def draw_screen_(self, indexed_items: list[Tuple[int, list[str]]], highlights: list[dict] = [{}], clear: bool = True) -> None:
+    def draw_screen_(self, clear: bool = True) -> None:
         """ Draw Picker screen. """
 
         self.logger.debug("Draw screen.")
@@ -787,16 +955,12 @@ class Picker:
         if clear:
             self.stdscr.erase()
 
-        h, w = self.stdscr.getmaxyx()
-        self.term_h, self.term_w = self.stdscr.getmaxyx()
-        if self.split_right and len(self.right_panes):
-            proportion = self.right_panes[self.right_pane_index]["proportion"]
-            self.rows_w, self.rows_h = int(self.term_w*proportion), self.term_h
-        else:
-            self.rows_w, self.rows_h = self.term_w, self.term_h
+        self.update_term_size()
 
-        # The height of the footer may need to be adjusted if the file changes.
+        # Determine footer size
         self.footer.adjust_sizes(self.term_h,self.term_w)
+
+        # The height of the footer may need to be adjusted if the file changes.
         self.calculate_section_sizes()
 
         # Test if the terminal is of a sufficient size to display the picker
@@ -814,27 +978,18 @@ class Picker:
             end_index = min(start_index + self.items_per_page, len(self.indexed_items))
         if len(self.indexed_items) == 0: start_index, end_index = 0, 0
 
-        # self.column_widths = get_column_widths(self.items, header=self.header, max_column_width=self.max_column_width, number_columns=self.number_columns, max_total_width=w)
-        # Determine widths based only on the currently indexed rows
-        # rows = [v[1] for v in self.indexed_items] if len(self.indexed_items) else self.items
-        # Determine widths based only on the currently displayed indexed rows
-        rows = [v[1] for v in self.indexed_items[start_index:end_index]] if len(self.indexed_items) else self.items
-        self.column_widths = get_column_widths(rows, header=self.header, max_column_width=self.max_column_width, number_columns=self.number_columns, max_total_width=self.rows_w, unicode_char_width=self.unicode_char_width)
-        visible_column_widths = [c for i,c in enumerate(self.column_widths) if i not in self.hidden_columns]
-        visible_columns_total_width = sum(visible_column_widths) + len(self.separator)*(len(visible_column_widths)-1)
-
-        # Determine the number of items_per_page, top_size and bottom_size
-        # self.calculate_section_sizes()
-        
-        # top_space = self.top_gap
+        self.get_visible_rows()
+        self.column_widths = get_column_widths(self.visible_rows, header=self.header, max_column_width=self.max_column_width, number_columns=self.number_columns, max_total_width=self.rows_w, unicode_char_width=self.unicode_char_width)
+        self.visible_column_widths = [c for i,c in enumerate(self.column_widths) if i not in self.hidden_columns]
+        visible_columns_total_width = sum(self.visible_column_widths) + len(self.separator)*(len(self.visible_column_widths)-1)
+
 
-        ## Display title (if applicable)
+        ## Display title
         if self.title:
             padded_title = f" {self.title.strip()} "
             self.stdscr.addstr(self.top_gap, 0, f"{' ':^{self.term_w}}", curses.color_pair(self.colours_start+16))
             title_x = (self.term_w-wcswidth(padded_title))//2
             self.stdscr.addstr(self.top_gap, title_x, padded_title, curses.color_pair(self.colours_start+16) | curses.A_BOLD)
-            # top_space += 1
 
         ## Display modes
         if self.display_modes and self.modes not in [[{}], []]:
@@ -856,7 +1011,6 @@ class Picker:
                 else:
                     self.stdscr.addstr(self.top_gap+1, xmode, mode_str, curses.color_pair(self.colours_start+15) | curses.A_UNDERLINE)
                 xmode += split_space+mode_widths[i]
-            # top_space += 1
 
         ## Display header
         if self.header and self.show_header:
@@ -874,137 +1028,129 @@ class Picker:
 
 
                 header_str += f"{col_str:^{self.column_widths[i]-len(number)}}"
-                header_str += self.separator
+                if i == self.selected_column-1:
+                    header_str += self.header_separator_before_selected_column
+                else:
+                    header_str += self.header_separator
+                header_str_w = min(self.rows_w-self.left_gutter_width, visible_columns_total_width+1, self.term_w-self.startx)
 
             header_str = header_str[self.leftmost_char:]
+            header_str = header_str[:header_str_w]
             header_ypos = self.top_gap + bool(self.title) + bool(self.display_modes and self.modes)
-            self.stdscr.addstr(header_ypos, 0, ' '*self.rows_w, curses.color_pair(self.colours_start+28) | curses.A_BOLD)
-            self.stdscr.addstr(header_ypos, self.startx, header_str[:min(self.rows_w-self.startx, visible_columns_total_width+1)], curses.color_pair(self.colours_start+4) | curses.A_BOLD)
+
+            # Ensure that the full header width is filled--important if the header rows do not fill the terminal width
+            self.stdscr.addstr(header_ypos, self.rows_box_x_i, ' '*self.rows_w, curses.color_pair(self.colours_start+28) | curses.A_BOLD)
+
+            # Draw header string
+            self.stdscr.addstr(header_ypos, self.startx, header_str, curses.color_pair(self.colours_start+4) | curses.A_BOLD)
 
             # Highlight sort column
-            try:
-                if self.selected_column != None and self.selected_column not in self.hidden_columns:
-                    # start of string is on screen
-                    col_width = self.column_widths[self.selected_column]
-                    number = f"{self.selected_column}. " if self.number_columns else ""
-                    col_str = self.header[self.selected_column][:self.column_widths[self.selected_column]-len(number)]
-                    highlighted_col_str = (number+f"{col_str:^{self.column_widths[self.selected_column]-len(number)}}") + self.separator
-
-                    if len(self.column_widths) == 1:
-                        colour = curses.color_pair(self.colours_start+28) | curses.A_BOLD
-                    else:
-                        colour = curses.color_pair(self.colours_start+19) | curses.A_BOLD
-                    # Start of selected column is on the screen
-                    if self.leftmost_char <= len(up_to_selected_col) and self.leftmost_char+self.rows_w-self.startx > len(up_to_selected_col):
-                        x_pos = len(up_to_selected_col) - self.leftmost_char + self.startx
-                        
-                        # Whole cell of the selected column is on the screen
-                        if len(up_to_selected_col)+col_width - self.leftmost_char < self.rows_w-self.startx:
-                            disp_str = highlighted_col_str
-                            
-                        # Start of the cell is on the screen, but the end of the cell is not
-                        else:
-                            overflow = (len(up_to_selected_col)+len(highlighted_col_str)) - (self.leftmost_char+self.rows_w - self.startx)
-                            disp_str = highlighted_col_str[:-overflow]
-
-                        self.stdscr.addstr(header_ypos, x_pos , disp_str, colour)
-                    # Start of the cell is to the right of the screen
-                    elif self.leftmost_char+self.rows_w <= len(up_to_selected_col):
-                        pass
-                    # The end of the cell is on the screen, the start of the cell is not
-                    elif 0 <= len(up_to_selected_col)+col_width - self.leftmost_char <= self.rows_w :
-                        x_pos = self.startx
-                        beg = self.leftmost_char - len(up_to_selected_col)
-                        disp_str = highlighted_col_str[beg:]
-                        self.stdscr.addstr(header_ypos, x_pos , disp_str, colour)
-                    # The middle of the cell is on the screen, the start and end of the cell are not
-                    elif self.leftmost_char <= len(up_to_selected_col) + col_width//2 <= self.leftmost_char+self.rows_w:
-                        beg = self.leftmost_char - len(up_to_selected_col)
-                        overflow = (len(up_to_selected_col)+len(highlighted_col_str)) - (self.leftmost_char+self.rows_w)
-                        disp_str = highlighted_col_str[beg:-overflow]
-
-                        x_pos = self.startx
-                        self.stdscr.addstr(header_ypos, x_pos , disp_str, colour)
-                    # The cell is to the left of the screen
+            if self.selected_column != None and self.selected_column not in self.hidden_columns:
+                # start of string is on screen
+                col_width = self.column_widths[self.selected_column]
+                number = f"{self.selected_column}. " if self.number_columns else ""
+                col_str = self.header[self.selected_column][:self.column_widths[self.selected_column]-len(number)]
+                highlighted_col_str = (number+f"{col_str:^{self.column_widths[self.selected_column]-len(number)}}") + self.separator
+
+                if len(self.column_widths) == 1:
+                    colour = curses.color_pair(self.colours_start+28) | curses.A_BOLD
+                else:
+                    colour = curses.color_pair(self.colours_start+19) | curses.A_BOLD
+                # Start of selected column is on the screen
+                if self.leftmost_char <= len(up_to_selected_col) and self.leftmost_char+self.rows_w-self.left_gutter_width > len(up_to_selected_col):
+                    x_pos = len(up_to_selected_col) - self.leftmost_char + self.startx
+
+                    # Whole cell of the selected column is on the screen
+                    if len(up_to_selected_col)+col_width - self.leftmost_char < self.rows_w-self.left_gutter_width:
+                        disp_str = highlighted_col_str
+
+                    # Start of the cell is on the screen, but the end of the cell is not
                     else:
-                        pass
-
-                    # elif self.leftmost_char:
-                    #     os.system(f"notify-send 'cell is to the right of the screen'")
-
-                    #
-                    #
-                    # if len(self.header) > 1 and (len(up_to_selected_col)-self.leftmost_char) < self.rows_w:
-                    #     number = f"{self.selected_column}. " if self.number_columns else ""
-                    #     # number = f"{intStringToExponentString(self.selected_column)}. " if self.number_columns else ""
-                    #     # self.startx + len(up_to_selected_col) - self.leftmost_char
-                    #     highlighed_col_startx = max(self.startx, self.startx + len(up_to_selected_col) - self.leftmost_char)
-                    #
-                    #
-                    #     col_str = self.header[self.selected_column][:self.column_widths[self.selected_column]-len(number)]
-                    #     highlighted_col_str = (number+f"{col_str:^{self.column_widths[self.selected_column]}}") + self.separator
-                    #     end_of_highlighted_col_str = self.rows_w-(highlighed_col_startx+len(highlighted_col_str)) if (highlighed_col_startx+len(highlighted_col_str)) > self.rows_w else len(highlighted_col_str)
-                    #     if (highlighed_col_startx+len(highlighted_col_str)) > self.rows_w:
-                    #         end_of_highlighted_col_str = self.rows_w-(highlighed_col_startx+len(highlighted_col_str)) 
-                    #     else:
-                    #         end_of_highlighted_col_str = len(highlighted_col_str)
-                    #
-                    #     start_of_highlighted_col_str = max(self.leftmost_char - len(up_to_selected_col), 0)
-                    #     self.stdscr.addstr(header_ypos, highlighed_col_startx , highlighted_col_str[start_of_highlighted_col_str:end_of_highlighted_col_str][:self.column_widths[self.selected_column]+len(self.separator)], curses.color_pair(self.colours_start+19) | curses.A_BOLD)
-            except:
-                pass
-                
+                        overflow = (len(up_to_selected_col)+len(highlighted_col_str)) - (self.leftmost_char+self.rows_w - self.left_gutter_width)
+                        disp_str = highlighted_col_str[:-overflow]
+                    disp_str_w = min(len(disp_str), self.term_w-x_pos)
+                    disp_str = truncate_to_display_width(disp_str, disp_str_w, self.centre_in_cols, self.unicode_char_width)
+
+                    self.stdscr.addstr(header_ypos, x_pos , disp_str, colour)
+                # Start of the cell is to the right of the screen
+                elif self.leftmost_char+self.rows_w <= len(up_to_selected_col):
+                    pass
+                # The end of the cell is on the screen, the start of the cell is not
+                elif 0 <= len(up_to_selected_col)+col_width - self.leftmost_char <= self.rows_w :
+                    x_pos = self.startx
+                    beg = self.leftmost_char - len(up_to_selected_col)
+                    disp_str = highlighted_col_str[beg:]
+                    disp_str_w = min(len(disp_str), self.term_w-x_pos)
+                    disp_str = truncate_to_display_width(disp_str, disp_str_w, self.centre_in_cols, self.unicode_char_width)
+                    self.stdscr.addstr(header_ypos, x_pos , disp_str, colour)
+                # The middle of the cell is on the screen, the start and end of the cell are not
+                elif self.leftmost_char <= len(up_to_selected_col) + col_width//2 <= self.leftmost_char+self.rows_w:
+                    beg = self.leftmost_char - len(up_to_selected_col)
+                    overflow = (len(up_to_selected_col)+len(highlighted_col_str)) - (self.leftmost_char+self.rows_w)
+                    x_pos = self.startx
+                    disp_str = highlighted_col_str[beg:-overflow]
+                    disp_str_w = min(len(disp_str), self.term_w-x_pos)
+                    disp_str = truncate_to_display_width(disp_str, disp_str_w, self.centre_in_cols, self.unicode_char_width)
+
+                    self.stdscr.addstr(header_ypos, x_pos , disp_str, colour)
+
+                # The cell is to the left of the focused part of the screen
+                else:
+                    pass
+
         # Display row header 
         if self.show_row_header:
             for idx in range(start_index, end_index):
                 y = idx - start_index + self.top_space
                 if idx == self.cursor_pos:
-                    self.stdscr.addstr(y, 0, f" {self.indexed_items[idx][0]} ", curses.color_pair(self.colours_start+19) | curses.A_BOLD)
+                    self.stdscr.addstr(y, self.startx-self.left_gutter_width, f" {self.indexed_items[idx][0]} ", curses.color_pair(self.colours_start+19) | curses.A_BOLD)
                 else:
-                    self.stdscr.addstr(y, 0, f" {self.indexed_items[idx][0]} ", curses.color_pair(self.colours_start+4) | curses.A_BOLD)
+                    self.stdscr.addstr(y, self.startx-self.left_gutter_width, f" {self.indexed_items[idx][0]} ", curses.color_pair(self.colours_start+4) | curses.A_BOLD)
 
 
         def highlight_cell(row: int, col:int, visible_column_widths, colour_pair_number: int = 5, bold: bool = False, y:int = 0):
-            
+
             cell_pos = sum(visible_column_widths[:col])+col*len(self.separator)-self.leftmost_char + self.startx
+            cell_pos_relative = sum(visible_column_widths[:col])+col*len(self.separator)-self.leftmost_char + self.left_gutter_width
             # cell_width = self.column_widths[self.selected_column]
             cell_width = visible_column_widths[col] + len(self.separator)
-            cell_max_width = self.rows_w-cell_pos
+            cell_max_width = min(self.rows_w-self.left_gutter_width, self.term_w-cell_pos)
 
             if bold:
                 colour = curses.color_pair(self.colours_start+colour_pair_number) | curses.A_BOLD
             else:
                 colour = curses.color_pair(self.colours_start+colour_pair_number)
-            try:
-                # Start of cell is on screen
-                if self.startx <= cell_pos <= self.rows_w:
-                    self.stdscr.addstr(y, cell_pos, (' '*cell_width)[:cell_max_width], colour)
-                    if self.centre_in_cols:
-                        cell_value = f"{self.indexed_items[row][1][col]:^{cell_width-len(self.separator)}}" + self.separator
-                    else:
-                        cell_value = self.indexed_items[row][1][col][:self.column_widths[col]] + self.separator
-                    # cell_value = cell_value[:min(cell_width, cell_max_width)-len(self.separator)]
-                    cell_value = truncate_to_display_width(cell_value, min(cell_width, cell_max_width), self.centre_in_cols, self.unicode_char_width)
-                    # cell_value = cell_value + self.separator
-                    # cell_value = cell_value
-                    cell_value = truncate_to_display_width(cell_value, min(cell_width, cell_max_width), self.centre_in_cols, self.unicode_char_width)
-                    self.stdscr.addstr(y, cell_pos, cell_value, colour)
-                # Part of the cell is on screen
-                elif self.startx <= cell_pos+cell_width and cell_pos < (self.rows_w):
-                    cell_start = self.startx - cell_pos
-                    # self.stdscr.addstr(y, self.startx, ' '*(cell_width-cell_start), curses.color_pair(self.colours_start+colour_pair_number))
-                    cell_value = self.indexed_items[row][1][col]
-                    cell_value = f"{cell_value:^{self.column_widths[col]}}"
-
-                    cell_value = cell_value[cell_start:visible_column_widths[col]][:self.rows_w-self.startx]
-                    self.stdscr.addstr(y, self.startx, cell_value, colour)
+            # Start of cell is on screen
+            if self.startx <= cell_pos <= self.rows_w+self.startx:
+                s = "max" if cell_max_width <= cell_width else "norm"
+                self.stdscr.addstr(y, cell_pos, (' '*cell_width)[:cell_max_width], colour)
+                if self.centre_in_cols:
+                    cell_value = f"{self.indexed_items[row][1][col]:^{cell_width-len(self.separator)}}" + self.separator
                 else:
-                    pass
-                # if colour_pair_number == 5:
-            except:
+                    cell_value = self.indexed_items[row][1][col][:self.column_widths[col]] + self.separator
+                cell_value = truncate_to_display_width(cell_value, min(cell_width, cell_max_width), self.centre_in_cols, self.unicode_char_width)
+                cell_value = truncate_to_display_width(cell_value, min(cell_width, cell_max_width), self.centre_in_cols, self.unicode_char_width)
+                if wcswidth(cell_value) + cell_pos > self.term_w:
+                    cell_value = truncate_to_display_width(cell_value, self.term_w-cell_pos-10, self.centre_in_cols, self.unicode_char_width)
+                self.stdscr.addstr(y, cell_pos, cell_value, colour)
+
+            # Part of the cell is on screen
+            elif self.startx <= cell_pos+cell_width and cell_pos <= (self.rows_w):
+                s = "max" if cell_max_width <= cell_width else "norm"
+                cell_start = self.startx - cell_pos
+                cell_value = self.indexed_items[row][1][col]
+                cell_value = f"{cell_value:^{self.column_widths[col]}}"
+
+                cell_value = cell_value[cell_start:visible_column_widths[col]][:self.rows_w-self.left_gutter_width]
+                cell_value = truncate_to_display_width(cell_value, min(wcswidth(cell_value), cell_width, cell_max_width), self.centre_in_cols, self.unicode_char_width)
+                cell_value += self.separator
+                cell_value = truncate_to_display_width(cell_value, min(wcswidth(cell_value), cell_width, cell_max_width), self.centre_in_cols, self.unicode_char_width)
+                self.stdscr.addstr(y, self.startx, cell_value, colour)
+            else:
                 pass
 
 
+
         def sort_highlights(highlights):
             """ 
             Sort highlights into lists based on their display level.
@@ -1045,10 +1191,11 @@ class Picker:
                         match = re.search(highlight["match"], truncate_to_display_width(item[1][highlight["field"]], self.column_widths[highlight["field"]], centre=False, unicode_char_width=self.unicode_char_width), re.IGNORECASE)
                         if not match: continue
                         field_start = sum([width for i, width in enumerate(self.column_widths[:highlight["field"]]) if i not in self.hidden_columns]) + sum([1 for i in range(highlight["field"]) if i not in self.hidden_columns])*wcswidth(self.separator)
+                        width = min(self.column_widths[highlight["field"]]-(field_start-self.leftmost_char), self.rows_w-self.left_gutter_width)
 
                         ## We want to search the non-centred values but highlight the centred values.
                         if self.centre_in_cols:
-                            tmp = truncate_to_display_width(item[1][highlight["field"]], self.column_widths[highlight["field"]], self.centre_in_cols, self.unicode_char_width)
+                            tmp = truncate_to_display_width(item[1][highlight["field"]], width, self.centre_in_cols, self.unicode_char_width)
                             field_start += (len(tmp) - len(tmp.lstrip()))
 
                         highlight_start = field_start + match.start()
@@ -1059,7 +1206,7 @@ class Picker:
                         continue
                     highlight_start -= self.leftmost_char
                     highlight_end -= self.leftmost_char
-                    self.stdscr.addstr(y, max(self.startx, self.startx+highlight_start), row_str[max(highlight_start,0):min(self.rows_w-self.startx, highlight_end)], curses.color_pair(self.colours_start+highlight["color"]) | curses.A_BOLD)
+                    self.stdscr.addstr(y, max(self.startx, self.startx+highlight_start), row_str[max(highlight_start,0):min(self.rows_w-self.left_gutter_width, highlight_end)], curses.color_pair(self.colours_start+highlight["color"]) | curses.A_BOLD)
                 except:
                     pass
 
@@ -1075,6 +1222,7 @@ class Picker:
         l0_highlights, l1_highlights, l2_highlights = sort_highlights(self.highlights)
 
 
+        row_width = sum(self.visible_column_widths) + len(self.separator)*(len(self.visible_column_widths)-1)
         for idx in range(start_index, end_index):
             item = self.indexed_items[idx]
             y = idx - start_index + self.top_space
@@ -1086,23 +1234,26 @@ class Picker:
             # rowstr off screen
             # if self.leftmost_char > len(row_str_orig):
             #     trunc_width = 0
-            if self.leftmost_char + (self.rows_w-self.startx) <= len(row_str_orig):
-                trunc_width = self.rows_w-self.startx
-            elif self.leftmost_char <= len(row_str_orig):
-                trunc_width = len(row_str_orig) - self.leftmost_char
-            else:
-                trunc_width = 0
+            # if self.leftmost_char + (self.rows_w-self.left_gutter_width) <= len(row_str_orig):
+            #     trunc_width = self.rows_w-self.startx
+            # elif self.leftmost_char <= len(row_str_orig):
+            #     trunc_width = len(row_str_orig) - self.leftmost_char
+            # else:
+            #     trunc_width = 0
+
+
+            trunc_width = max(0, min(self.rows_w-self.left_gutter_width, row_width, self.term_w - self.startx))
 
             row_str = truncate_to_display_width(row_str_left_adj, trunc_width, self.unicode_char_width)
             # row_str = truncate_to_display_width(row_str, min(w-self.startx, visible_columns_total_width))[self.leftmost_char:]
 
             ## Display the standard row
-            self.stdscr.addstr(y, self.startx, row_str[:min(self.rows_w-self.startx, visible_columns_total_width)], curses.color_pair(self.colours_start+2))
-            
+            self.stdscr.addstr(y, self.startx, row_str, curses.color_pair(self.colours_start+2))
+
 
             ## Highlight column
             if self.crosshair_cursor:
-                highlight_cell(idx, self.selected_column, visible_column_widths, colour_pair_number=27, bold=False, y=y)
+                highlight_cell(idx, self.selected_column, self.visible_column_widths, colour_pair_number=27, bold=False, y=y)
                 if idx == self.cursor_pos:
                     self.stdscr.addstr(y, self.startx, row_str[:min(self.rows_w-self.startx, visible_columns_total_width)], curses.color_pair(self.colours_start+27))
 
@@ -1116,25 +1267,25 @@ class Picker:
                 # self.selected_cells_by_row = get_selected_cells_by_row(self.cell_selections)
                 if item[0] in self.selected_cells_by_row:
                     for j in self.selected_cells_by_row[item[0]]:
-                        highlight_cell(idx, j, visible_column_widths, colour_pair_number=25, bold=False, y=y)
+                        highlight_cell(idx, j, self.visible_column_widths, colour_pair_number=25, bold=False, y=y)
 
                 # Visually selected
                 if self.is_selecting:
                     if self.start_selection <= idx <= self.cursor_pos or self.start_selection >= idx >= self.cursor_pos:
                         x_interval = range(min(self.start_selection_col, self.selected_column), max(self.start_selection_col, self.selected_column)+1)
                         for col in x_interval:
-                            highlight_cell(idx, col, visible_column_widths, colour_pair_number=25, bold=False, y=y)
+                            highlight_cell(idx, col, self.visible_column_widths, colour_pair_number=25, bold=False, y=y)
 
                 # Visually deslected
                 if self.is_deselecting:
                     if self.start_selection >= idx >= self.cursor_pos or self.start_selection <= idx <= self.cursor_pos:
                         x_interval = range(min(self.start_selection_col, self.selected_column), max(self.start_selection_col, self.selected_column)+1)
                         for col in x_interval:
-                            highlight_cell(idx, col, visible_column_widths, colour_pair_number=26, bold=False,y=y)
+                            highlight_cell(idx, col, self.visible_column_widths, colour_pair_number=26, bold=False,y=y)
             # Higlight cursor row and selected rows
             elif self.highlight_full_row:
                 if self.selections[item[0]]:
-                    self.stdscr.addstr(y, self.startx, row_str[:min(self.rows_w-self.startx, visible_columns_total_width)], curses.color_pair(self.colours_start+25) | curses.A_BOLD)
+                    self.stdscr.addstr(y, self.startx, row_str[:min(self.rows_w-self.left_gutter_width, visible_columns_total_width)], curses.color_pair(self.colours_start+25) | curses.A_BOLD)
 
                 # Visually selected
                 if self.is_selecting:
@@ -1147,16 +1298,30 @@ class Picker:
 
             # Highlight the cursor row and the first char of the selected rows.
             else:
-                if self.selections[item[0]]:
-                    self.stdscr.addstr(y, max(self.startx-2,0), ' ', curses.color_pair(self.colours_start+1))
-                # Visually selected
-                if self.is_selecting:
-                    if self.start_selection <= idx <= self.cursor_pos or self.start_selection >= idx >= self.cursor_pos:
+                if self.selected_char:
+                    if self.selections[item[0]]:
+                        self.stdscr.addstr(y, max(self.startx-2,0), self.selected_char, curses.color_pair(self.colours_start+2))
+                    else:
+                        self.stdscr.addstr(y, max(self.startx-2,0), self.unselected_char, curses.color_pair(self.colours_start+2))
+                    # Visually selected
+                    if self.is_selecting:
+                        if self.start_selection <= idx <= self.cursor_pos or self.start_selection >= idx >= self.cursor_pos:
+                            self.stdscr.addstr(y, max(self.startx-2,0), self.selecting_char, curses.color_pair(self.colours_start+2))
+                    # Visually deslected
+                    if self.is_deselecting:
+                        if self.start_selection >= idx >= self.cursor_pos or self.start_selection <= idx <= self.cursor_pos:
+                            self.stdscr.addstr(y, max(self.startx-2,0), self.deselecting_char, curses.color_pair(self.colours_start+2))
+                else:
+                    if self.selections[item[0]]:
                         self.stdscr.addstr(y, max(self.startx-2,0), ' ', curses.color_pair(self.colours_start+1))
-                # Visually deslected
-                if self.is_deselecting:
-                    if self.start_selection >= idx >= self.cursor_pos or self.start_selection <= idx <= self.cursor_pos:
-                        self.stdscr.addstr(y, max(self.startx-2,0), ' ', curses.color_pair(self.colours_start+10))
+                    # Visually selected
+                    if self.is_selecting:
+                        if self.start_selection <= idx <= self.cursor_pos or self.start_selection >= idx >= self.cursor_pos:
+                            self.stdscr.addstr(y, max(self.startx-2,0), ' ', curses.color_pair(self.colours_start+1))
+                    # Visually deslected
+                    if self.is_deselecting:
+                        if self.start_selection >= idx >= self.cursor_pos or self.start_selection <= idx <= self.cursor_pos:
+                            self.stdscr.addstr(y, max(self.startx-2,0), ' ', curses.color_pair(self.colours_start+10))
 
             if not self.highlights_hide:
                 draw_highlights(l1_highlights, idx, y, item)
@@ -1166,10 +1331,10 @@ class Picker:
             # Draw cursor
             if idx == self.cursor_pos:
                 if self.cell_cursor:
-                    highlight_cell(idx, self.selected_column, visible_column_widths, colour_pair_number=5, bold=True, y=y)
+                    highlight_cell(idx, self.selected_column, self.visible_column_widths, colour_pair_number=5, bold=True, y=y)
                 else:
-                    self.stdscr.addstr(y, self.startx, row_str[:min(self.rows_w-self.startx, visible_columns_total_width)], curses.color_pair(self.colours_start+5) | curses.A_BOLD)
-            
+                    self.stdscr.addstr(y, self.startx, row_str[:self.rows_w-self.left_gutter_width], curses.color_pair(self.colours_start+5) | curses.A_BOLD)
+
             if not self.highlights_hide:
                 draw_highlights(l2_highlights, idx, y, item)
 
@@ -1188,7 +1353,8 @@ class Picker:
             scroll_bar_length = max(1, scroll_bar_length)
             for i in range(scroll_bar_length):
                 v = max(self.top_space+int(bool(self.header)), scroll_bar_start-scroll_bar_length//2)
-                self.stdscr.addstr(scroll_bar_start+i, self.rows_w-1, ' ', curses.color_pair(self.colours_start+18))
+                # self.stdscr.addstr(scroll_bar_start+i, self.startx+self.rows_w-self.left_gutter_width-2, ' ', curses.color_pair(self.colours_start+18))
+                self.stdscr.addstr(scroll_bar_start+i, self.rows_box_x_f-1, ' ', curses.color_pair(self.colours_start+18))
 
         # Display refresh symbol
         if self.auto_refresh:
@@ -1197,10 +1363,14 @@ class Picker:
             else:
                 self.stdscr.addstr(0,self.term_w-3,"  ", curses.color_pair(self.colours_start+23) | curses.A_BOLD)
 
+        # Display data fetch symbol
+        if not self.getting_data.is_set():
+            self.stdscr.addstr(0,self.term_w-3,"  ", curses.color_pair(self.colours_start+21) | curses.A_BOLD)
+            # self.stdscr.addstr(0,self.term_w-6,"⏳", curses.color_pair(self.colours_start+21) | curses.A_BOLD)
+
         ## Display footer
         if self.show_footer:
             # self.footer = NoFooter(self.stdscr, self.colours_start, self.get_function_data)
-            h, w = self.stdscr.getmaxyx()
             try:
                 self.footer.draw(self.term_h, self.term_w)
             except:
@@ -1213,41 +1383,83 @@ class Picker:
 
         if self.split_right and len(self.right_panes):
             # If we need to refresh the data then do so.
-            if self.right_panes[self.right_pane_index]["auto_refresh"] and ((time.time() - self.initial_split_time) > self.right_panes[self.right_pane_index]["refresh_time"]):
-                get_data = self.right_panes[self.right_pane_index]["get_data"]
-                data = self.right_panes[self.right_pane_index]["data"]
-                self.right_panes[self.right_pane_index]["data"] = get_data(data, self.get_function_data())
-                self.initial_split_time = time.time()
+            pane = self.right_panes[self.right_pane_index]
+            if pane["auto_refresh"] and ((time.time() - self.initial_right_split_time) > pane["refresh_time"]):
+                get_data = pane["get_data"]
+                data = pane["data"]
+                pane["data"] = get_data(data, self.get_function_data())
+                self.initial_right_split_time = time.time()
 
-            draw_pane = self.right_panes[self.right_pane_index]["display"]
-            data = self.right_panes[self.right_pane_index]["data"]
+            draw_pane = pane["display"]
+            data = pane["data"]
+            # pane_width = int(pane["proportion"]*self.term_w)
 
             draw_pane(
                 self.stdscr, 
-                x = self.rows_w,
+                x = self.rows_w + self.startx - self.left_gutter_width,
                 y = self.top_space - int(bool(self.show_header and self.header)),
-                w = self.term_w-self.rows_w,
+                w = self.right_pane_width,
                 h = self.items_per_page + int(bool(self.show_header and self.header)),
                 state = self.get_function_data(),
                 row = self.indexed_items[self.cursor_pos] if self.indexed_items else [],
                 cell = self.indexed_items[self.cursor_pos][1][self.selected_column] if self.indexed_items else "",
                 data=data,
             )
-        
-        self.stdscr.refresh()
+        if self.split_left and len(self.left_panes):
+            # If we need to refresh the data then do so.
+            pane = self.left_panes[self.left_pane_index]
+            if pane["auto_refresh"] and ((time.time() - self.initial_left_split_time) > pane["refresh_time"]):
+                get_data = pane["get_data"]
+                data = pane["data"]
+                pane["data"] = get_data(data, self.get_function_data())
+                self.initial_left_split_time = time.time()
+
+            draw_pane = pane["display"]
+            data = pane["data"]
+            # pane_width = int(pane["proportion"]*self.term_w)
+
+            draw_pane(
+                self.stdscr, 
+                x = 0,
+                y = self.top_space - int(bool(self.show_header and self.header)),
+                w = self.left_pane_width,
+                h = self.items_per_page + int(bool(self.show_header and self.header)),
+                state = self.get_function_data(),
+                row = self.indexed_items[self.cursor_pos] if self.indexed_items else [],
+                cell = self.indexed_items[self.cursor_pos][1][self.selected_column] if self.indexed_items else "",
+                data=data,
+            )
+
         ## Display infobox
         if self.display_infobox:
             self.infobox(self.stdscr, message=self.infobox_items, title=self.infobox_title)
             # self.stdscr.timeout(2000)  # timeout is set to 50 in order to get the infobox to be displayed so here we reset it to 2000
 
 
+    def refresh_and_draw_screen(self):
+        """
+        Clears and refreshes the screen, restricts and unrestricts curses, 
+            ensures correct terminal settings, and then draws the screen.
+        """
+
+        self.logger.info(f"key_function redraw_screen")
+        self.stdscr.clear()
+        self.stdscr.refresh()
+        restrict_curses(self.stdscr)
+        unrestrict_curses(self.stdscr)
+        self.stdscr.clear()
+        self.stdscr.refresh()
+
+        self.draw_screen()
 
     def infobox(self, stdscr: curses.window, message: str ="", title: str ="Infobox",  colours_end: int = 0, duration: int = 4) -> curses.window:
         """ Display non-interactive infobox window. """
 
         self.logger.info(f"function: infobox()")
-        h, w = stdscr.getmaxyx()
-        notification_width, notification_height = w//2, 3*h//5
+        self.update_term_size()
+
+
+        notification_width, notification_height = self.term_w//2, 3*self.term_h//5
         message_width = notification_width-5
 
         if not message: message = "!!"
@@ -1263,9 +1475,9 @@ class Picker:
         if len(submenu_items) > notification_height - 2:
             submenu_items = submenu_items[:notification_height-3] + [f"{'....':^{notification_width}}"]
         while True:
-            h, w = stdscr.getmaxyx()
 
-            submenu_win = curses.newwin(notification_height, notification_width, 3, w - (notification_width+4))
+            self.update_term_size()
+            submenu_win = curses.newwin(notification_height, notification_width, 3, self.term_w - (notification_width+4))
             infobox_data = {
                 "items": submenu_items,
                 "colours": notification_colours,
@@ -1280,6 +1492,7 @@ class Picker:
                 "reset_colours": False,
                 "cell_cursor": False,
                 "split_right": False,
+                "split_left": False,
                 "crosshair_cursor": False,
             }
 
@@ -1293,113 +1506,127 @@ class Picker:
         self.logger.debug(f"function: get_function_data()")
         """ Returns a dict of the main variables needed to restore the state of list_pikcer. """
         function_data = {
-            "selections":                       self.selections,
-            "cell_selections":                  self.cell_selections,
-            "selected_cells_by_row":            self.selected_cells_by_row,
-            "items_per_page":                   self.items_per_page,
-            "current_row":                      self.current_row,
-            "current_page":                     self.current_page,
-            "cursor_pos":                       self.cursor_pos,
-            "colours":                          self.colours,
-            "colour_theme_number":              self.colour_theme_number,
-            "selected_column":                  self.selected_column,
-            "sort_column":                      self.sort_column,
-            "sort_method":                      self.sort_method,
-            "sort_reverse":                     self.sort_reverse,
-            "SORT_METHODS":                     self.SORT_METHODS,
-            "hidden_columns":                   self.hidden_columns,
-            "is_selecting":                     self.is_selecting,
-            "is_deselecting":                   self.is_deselecting,
-            "user_opts":                        self.user_opts,
-            "options_list":                     self.options_list,
-            "user_settings":                    self.user_settings,
-            "separator":                        self.separator,
-            "search_query":                     self.search_query,
-            "search_count":                     self.search_count,
-            "search_index":                     self.search_index,
-            "filter_query":                     self.filter_query,
-            "indexed_items":                    self.indexed_items,
-            "start_selection":                  self.start_selection,
-            "start_selection_col":              self.start_selection_col,
-            "end_selection":                    self.end_selection,
-            "highlights":                       self.highlights,
-            "max_column_width":                 self.max_column_width,
-            "column_indices":                   self.column_indices,
-            "mode_index":                       self.mode_index,
-            "modes":                            self.modes,
-            "title":                            self.title,
-            "display_modes":                    self.display_modes,
-            "require_option":                   self.require_option,
-            "require_option_default":           self.require_option_default,
-            "option_functions":                 self.option_functions,
-            "top_gap":                          self.top_gap,
-            "number_columns":                   self.number_columns,
-            "items":                            self.items,
-            "indexed_items":                    self.indexed_items,
-            "header":                           self.header,
-            "scroll_bar":                       self.scroll_bar,
-            "columns_sort_method":              self.columns_sort_method,
-            "disabled_keys":                    self.disabled_keys,
-            "show_footer":                      self.show_footer,
-            "footer_string":                    self.footer_string,
-            "footer_string_auto_refresh":       self.footer_string_auto_refresh,
-            "footer_string_refresh_function":   self.footer_string_refresh_function,
-            "footer_timer":                     self.footer_timer,
-            "footer_style":                     self.footer_style,
-            "colours_start":                    self.colours_start,
-            "colours_end":                      self.colours_end,
-            "display_only":                     self.display_only,
-            "infobox_items":                    self.infobox_items,
-            "display_infobox":                  self.display_infobox,
-            "infobox_title":                    self.infobox_title,
-            "key_remappings":                   self.key_remappings,
-            "auto_refresh":                     self.auto_refresh,
-            "get_new_data":                     self.get_new_data,
-            "refresh_function":                 self.refresh_function,
-            "timer":                            self.timer,
-            "get_data_startup":                 self.get_data_startup,
-            "get_footer_string_startup":        self.get_footer_string_startup,
-            "editable_columns":                 self.editable_columns,
-            "last_key":                         self.last_key,
-            "centre_in_terminal":               self.centre_in_terminal,
-            "centre_in_terminal_vertical":      self.centre_in_terminal_vertical,
-            "centre_in_cols":                   self.centre_in_cols,
-            "highlight_full_row":               self.highlight_full_row,
-            "cell_cursor":                      self.cell_cursor,
-            "column_widths":                    self.column_widths,
-            "track_entries_upon_refresh":       self.track_entries_upon_refresh,
-            "pin_cursor":                       self.pin_cursor,
-            "id_column":                        self.id_column,
-            "startup_notification":             self.startup_notification,
-            "keys_dict":                        self.keys_dict,
-            "cancel_is_back":                   self.cancel_is_back,
-            "paginate":                         self.paginate,
-            "leftmost_char":                    self.leftmost_char,
-            "history_filter_and_search" :       self.history_filter_and_search,
-            "history_pipes" :                   self.history_pipes,
-            "history_opts" :                    self.history_opts,
-            "history_edits" :                   self.history_edits,
-            "history_settings":                 self.history_settings,
-            "show_header":                      self.show_header,
-            "show_row_header":                  self.show_row_header,
-            "debug":                            self.debug,
-            "debug_level":                      self.debug_level,
-            "reset_colours":                    self.reset_colours,
-            "unicode_char_width":               self.unicode_char_width,
-            "command_stack":                    self.command_stack,
-            "loaded_file":                      self.loaded_file,
-            "loaded_files":                     self.loaded_files,
-            "loaded_file_index":                self.loaded_file_index,
-            "loaded_file_states":               self.loaded_file_states,
-            "sheet_index":                      self.sheet_index,
-            "sheets":                           self.sheets,
-            "sheet_name":                       self.sheet_name,
-            "sheet_states":                     self.sheet_states,
-            "split_right":                      self.split_right,
-            "right_panes":                      self.right_panes,
-            "right_pane_index":                 self.right_pane_index,
-            "crosshair_cursor":                 self.crosshair_cursor,
-
+            "self":                                     self,
+            "selections":                               self.selections,
+            "cell_selections":                          self.cell_selections,
+            "selected_cells_by_row":                    self.selected_cells_by_row,
+            "items_per_page":                           self.items_per_page,
+            "current_row":                              self.current_row,
+            "current_page":                             self.current_page,
+            "cursor_pos":                               self.cursor_pos,
+            "colours":                                  self.colours,
+            "colour_theme_number":                      self.colour_theme_number,
+            "selected_column":                          self.selected_column,
+            "sort_column":                              self.sort_column,
+            "sort_method":                              self.sort_method,
+            "sort_reverse":                             self.sort_reverse,
+            "SORT_METHODS":                             self.SORT_METHODS,
+            "hidden_columns":                           self.hidden_columns,
+            "is_selecting":                             self.is_selecting,
+            "is_deselecting":                           self.is_deselecting,
+            "user_opts":                                self.user_opts,
+            "options_list":                             self.options_list,
+            "user_settings":                            self.user_settings,
+            "separator":                                self.separator,
+            "header_separator":                         self.header_separator,
+            "header_separator_before_selected_column":  self.header_separator_before_selected_column,
+            "search_query":                             self.search_query,
+            "search_count":                             self.search_count,
+            "search_index":                             self.search_index,
+            "filter_query":                             self.filter_query,
+            "indexed_items":                            self.indexed_items,
+            "start_selection":                          self.start_selection,
+            "start_selection_col":                      self.start_selection_col,
+            "end_selection":                            self.end_selection,
+            "highlights":                               self.highlights,
+            "max_column_width":                         self.max_column_width,
+            "column_indices":                           self.column_indices,
+            "mode_index":                               self.mode_index,
+            "modes":                                    self.modes,
+            "title":                                    self.title,
+            "display_modes":                            self.display_modes,
+            "require_option":                           self.require_option,
+            "require_option_default":                   self.require_option_default,
+            "option_functions":                         self.option_functions,
+            "top_gap":                                  self.top_gap,
+            "number_columns":                           self.number_columns,
+            "items":                                    self.items,
+            "indexed_items":                            self.indexed_items,
+            "header":                                   self.header,
+            "scroll_bar":                               self.scroll_bar,
+            "columns_sort_method":                      self.columns_sort_method,
+            "disabled_keys":                            self.disabled_keys,
+            "show_footer":                              self.show_footer,
+            "footer_string":                            self.footer_string,
+            "footer_string_auto_refresh":               self.footer_string_auto_refresh,
+            "footer_string_refresh_function":           self.footer_string_refresh_function,
+            "footer_timer":                             self.footer_timer,
+            "footer_style":                             self.footer_style,
+            "colours_start":                            self.colours_start,
+            "colours_end":                              self.colours_end,
+            "display_only":                             self.display_only,
+            "infobox_items":                            self.infobox_items,
+            "display_infobox":                          self.display_infobox,
+            "infobox_title":                            self.infobox_title,
+            "key_remappings":                           self.key_remappings,
+            "auto_refresh":                             self.auto_refresh,
+            "get_new_data":                             self.get_new_data,
+            "refresh_function":                         self.refresh_function,
+            "timer":                                    self.timer,
+            "get_data_startup":                         self.get_data_startup,
+            "get_footer_string_startup":                self.get_footer_string_startup,
+            "editable_columns":                         self.editable_columns,
+            "last_key":                                 self.last_key,
+            "centre_in_terminal":                       self.centre_in_terminal,
+            "centre_in_terminal_vertical":              self.centre_in_terminal_vertical,
+            "centre_in_cols":                           self.centre_in_cols,
+            "highlight_full_row":                       self.highlight_full_row,
+            "cell_cursor":                              self.cell_cursor,
+            "column_widths":                            self.column_widths,
+            "track_entries_upon_refresh":               self.track_entries_upon_refresh,
+            "pin_cursor":                               self.pin_cursor,
+            "id_column":                                self.id_column,
+            "startup_notification":                     self.startup_notification,
+            "keys_dict":                                self.keys_dict,
+            "macros":                                   self.macros,
+            "cancel_is_back":                           self.cancel_is_back,
+            "paginate":                                 self.paginate,
+            "leftmost_char":                            self.leftmost_char,
+            "history_filter_and_search" :               self.history_filter_and_search,
+            "history_pipes" :                           self.history_pipes,
+            "history_opts" :                            self.history_opts,
+            "history_edits" :                           self.history_edits,
+            "history_settings":                         self.history_settings,
+            "show_header":                              self.show_header,
+            "show_row_header":                          self.show_row_header,
+            "debug":                                    self.debug,
+            "debug_level":                              self.debug_level,
+            "reset_colours":                            self.reset_colours,
+            "unicode_char_width":                       self.unicode_char_width,
+            "command_stack":                            self.command_stack,
+            "loaded_file":                              self.loaded_file,
+            "loaded_files":                             self.loaded_files,
+            "loaded_file_index":                        self.loaded_file_index,
+            "loaded_file_states":                       self.loaded_file_states,
+            "sheet_index":                              self.sheet_index,
+            "sheets":                                   self.sheets,
+            "sheet_name":                               self.sheet_name,
+            "sheet_states":                             self.sheet_states,
+            "split_right":                              self.split_right,
+            "right_panes":                              self.right_panes,
+            "right_pane_index":                         self.right_pane_index,
+            "split_left":                               self.split_left,
+            "left_panes":                               self.left_panes,
+            "left_pane_index":                          self.left_pane_index,
+            "crosshair_cursor":                         self.crosshair_cursor,
+            "generate_data_for_hidden_columns":         self.generate_data_for_hidden_columns,
+            "thread_stop_event":                        self.thread_stop_event,
+            "data_generation_queue":                    self.data_generation_queue,
+            "process_manager":                          self.process_manager,
+            "threads":                                  self.threads,
+            "processes":                                self.processes,
+            "items_sync_loop_event":                    self.items_sync_loop_event,
+            "items_sync_thread":                        self.items_sync_thread,
         }
         return function_data
 
@@ -1435,6 +1662,9 @@ class Picker:
             "centre_in_cols",
             "centre_in_terminal",
             "split_right",
+            "left_pane_index",
+            "split_left",
+            "left_pane_index",
         ]
 
         for var in variables:
@@ -1449,15 +1679,6 @@ class Picker:
         self.initialise_picker_state(reset_colours=reset_colours)
 
         self.initialise_variables()
-        # if "colour_theme_number" in function_data:
-        #     global COLOURS_SET
-        #     COLOURS_SET = False
-        #     colours_end = set_colours(pick=self.colour_theme_number, start=self.colours_start)
-                
-        # if "items" in function_data: self.items = function_data["items"]
-        # if "header" in function_data: self.header = function_data["header"]
-        # self.indexed_items = function_data["indexed_items"] if "indexed_items" in function_data else []
-
 
 
     def delete_entries(self) -> None:
@@ -1475,7 +1696,7 @@ class Picker:
         self.selections = {i:False for i in range(len(self.indexed_items))}
         self.cursor_pos = min(self.cursor_pos, len(self.indexed_items)-1)
         self.initialise_variables()
-        self.draw_screen(self.indexed_items, self.highlights)
+        self.draw_screen()
 
 
     def choose_option(
@@ -1528,35 +1749,134 @@ class Picker:
             "number_columns": False,
             "reset_colours": False,
             "split_right": False,
+            "split_left": False,
             "cell_cursor": False,
             "crosshair_cursor": False,
+            "header_separator": " │",
         }
         while True:
-            h, w = stdscr.getmaxyx()
+            self.update_term_size()
 
             choose_opts_widths = get_column_widths(options, unicode_char_width=self.unicode_char_width)
-            window_width = min(max(sum(choose_opts_widths) + 6, 50) + 6, w)
-            window_height = min(h//2, max(6, len(options)+3))
+            window_width = min(max(sum(choose_opts_widths) + 6, 50) + 6, self.term_w)
+            window_height = min(self.term_h//2, max(6, len(options)+3))
 
-            submenu_win = curses.newwin(window_height, window_width, (h-window_height)//2, (w-window_width)//2)
+            submenu_win = curses.newwin(window_height, window_width, (self.term_h-window_height)//2, (self.term_w-window_width)//2)
             submenu_win.keypad(True)
+            option_picker_data["screen_size_function"] = lambda stdscr: (window_height, window_width)
             OptionPicker = Picker(submenu_win, **option_picker_data)
             s, o, f = OptionPicker.run()
 
             if o == "refresh": 
-                self.draw_screen(self.indexed_items, self.highlights)
+                self.draw_screen()
                 continue
             if s:
                 return {x: options[x] for x in s}, o, f
             return {}, "", f
             
 
+    def select_columns(
+            self,
+            stdscr: curses.window,
+            # options: list[list[str]] =[],
+            # title: str = "Choose option",
+            # x:int=0,
+            # y:int=0,
+            # literal:bool=False,
+            # colours_start:int=0,
+            # header: list[str] = [],
+            # require_option:list = [],
+            # option_functions: list = [],
+    ) -> Tuple[dict, str, dict]:
+        """
+        Display input field at x,y
+
+        ---Arguments
+            stdscr: curses screen
+            usrtxt (str): text to be edited by the user
+            title (str): The text to be displayed at the start of the text option picker
+            x (int): prompt begins at (x,y) in the screen given
+            y (int): prompt begins at (x,y) in the screen given
+            colours_start (bool): start index of curses init_pair.
+
+        ---Returns
+            usrtxt, return_code
+            usrtxt: the text inputted by the user
+            return_code: 
+                            0: user hit escape
+                            1: user hit return
+        """
+        self.logger.info(f"function: select_columns()")
+
+        cursor = 0
+
+        if self.header:
+            columns = [s for i, s in enumerate(self.header)]
+        else:
+            columns = [f"" for i in range(len(self.column_widths))]
+        
+        ## Column info variable
+        columns_set = [[f"{i}", columns[i]] for i in range(len(self.column_widths))]
+        header = ["#", "Column Name"]
+
+        selected = [False if i in self.hidden_columns else True for i in range(len(self.column_widths))]
+        selected = {i: False if i in self.hidden_columns else True for i in range(len(self.column_widths))}
+
+        option_picker_data = {
+            "items": columns_set,
+            "colours": notification_colours,
+            "colours_start": self.notification_colours_start,
+            "title":"Select Columns",
+            "header": header,
+            "hidden_columns":[],
+            # "require_option":require_option,
+            # "keys_dict": options_keys,
+            "selections": selected,
+            "show_footer": False,
+            "cancel_is_back": True,
+            "number_columns": False,
+            "reset_colours": False,
+            "split_right": False,
+            "split_left": False,
+            "cell_cursor": False,
+            "crosshair_cursor": False,
+            "separator": "  ",
+            "header_separator": " │",
+            "header_separator_before_selected_column": " ▐",
+            "selected_char": "☒",
+            "unselected_char": "☐",
+            "selecting_char": "☒",
+            "deselecting_char": "☐",
+        }
+        while True:
+            self.update_term_size()
+
+            choose_opts_widths = get_column_widths(columns_set, unicode_char_width=self.unicode_char_width)
+            window_width = min(max(sum(choose_opts_widths) + 6, 50) + 6, self.term_w)
+            window_height = min(self.term_h//2, max(6, len(columns_set)+3))
+
+            submenu_win = curses.newwin(window_height, window_width, (self.term_h-window_height)//2, (self.term_w-window_width)//2)
+            submenu_win.keypad(True)
+            option_picker_data["screen_size_function"] = lambda stdscr: (window_height, window_width)
+            OptionPicker = Picker(submenu_win, **option_picker_data)
+            s, o, f = OptionPicker.run()
+
+            if o == "refresh": 
+                self.draw_screen()
+                continue
+            if s:
+                selected_columns = s
+                self.hidden_columns = [i for i in range(len(self.column_widths)) if i not in selected_columns]
+
+                # return {x: options[x] for x in s}, o, f
+                break
+            return {}, "", f
 
     def notification(self, stdscr: curses.window, message: str="", title:str="Notification", colours_end: int=0, duration:int=4) -> None:
 
         self.logger.info(f"function: notification()")
         """ Notification box. """
-        notification_width, notification_height = 50, 7
+        notification_width, notification_height = min(self.term_w-4, 50), 7
         message_width = notification_width-5
 
         if not message: message = "!!"
@@ -1569,9 +1889,9 @@ class Picker:
             27: ord('q')
         }
         while True:
-            h, w = stdscr.getmaxyx()
+            self.update_term_size()
 
-            submenu_win = curses.newwin(notification_height, notification_width, 3, w - (notification_width+4))
+            submenu_win = curses.newwin(notification_height, notification_width, 3, self.term_w - (notification_width+2))
             notification_data = {
                 "items": submenu_items,
                 "title": title,
@@ -1588,9 +1908,11 @@ class Picker:
                 "cancel_is_back": True,
                 "reset_colours": False,
                 "split_right": False,
+                "split_left": False,
                 "cell_cursor": False,
                 "crosshair_cursor": False,
-
+                "show_header": False,
+                "screen_size_function": lambda stdscr: (notification_height, notification_width),
             }
             OptionPicker = Picker(submenu_win, **notification_data)
             s, o, f = OptionPicker.run()
@@ -1601,7 +1923,7 @@ class Picker:
             del submenu_win
             stdscr.clear()
             stdscr.refresh()
-            self.draw_screen(self.indexed_items, self.highlights)
+            self.draw_screen()
         # set_colours(colours=get_colours(0))
 
     def toggle_column_visibility(self, col_index:int) -> None:
@@ -1708,7 +2030,7 @@ class Picker:
                 elif setting == "file_prev":
                     self.command_stack.append(Command("setting", self.user_settings))
                     self.switch_file(increment=-1)
-                    # self.draw_screen(self.indexed_items, self.highlights)
+                    # self.draw_screen()
                     # self.stdscr.refresh()
 
                 elif setting == "sheet_next":
@@ -1727,14 +2049,24 @@ class Picker:
                         self.footer_style = (self.footer_style+1)%len(self.footer_options)
                         self.footer = self.footer_options[self.footer_style]
                     self.initialise_variables()
-                elif setting == "pane":
+                elif setting == "rpane":
                     self.toggle_right_pane()
 
-                elif setting == "pane_cycle":
+                elif setting == "rpane_cycle":
                     self.cycle_right_pane()
 
+                elif setting == "lpane":
+                    self.toggle_left_pane()
+
+                elif setting == "lpane_cycle":
+                    self.cycle_left_pane()
+
                 elif setting.startswith("cwd="):
                     os.chdir(os.path.expandvars(os.path.expanduser(setting[len("cwd="):])))
+                elif setting.startswith("lmc="):
+                    rem = setting[4:]
+                    if rem.isnumeric():
+                        self.leftmost_char = int(rem)
                 elif setting.startswith("hl"):
                     hl_list = setting.split(",")
                     if len(hl_list) > 1:
@@ -1772,7 +2104,7 @@ class Picker:
                             theme_number = int(setting[2:].strip())
                             self.colour_theme_number = min(get_theme_count()-1, theme_number)
                             set_colours(self.colour_theme_number)
-                            self.draw_screen(self.indexed_items, self.highlights)
+                            self.draw_screen()
                             self.notification(self.stdscr, message=f"Theme {self.colour_theme_number} applied.")
                         except:
                             pass
@@ -1781,8 +2113,12 @@ class Picker:
                         self.colour_theme_number = (self.colour_theme_number + 1)%get_theme_count()
                         # self.colour_theme_number = int(not bool(self.colour_theme_number))
                         set_colours(self.colour_theme_number)
-                        self.draw_screen(self.indexed_items, self.highlights)
+                        self.draw_screen()
                         self.notification(self.stdscr, message=f"Theme {self.colour_theme_number} applied.")
+                    self.colours = get_colours(self.colour_theme_number)
+                elif setting == "colsel":
+                    self.draw_screen()
+                    self.select_columns(self.stdscr)
 
                 else:
                     self.user_settings = ""
@@ -1807,7 +2143,7 @@ class Picker:
         """ Toggle selection of item at index. """
         self.logger.info(f"function: toggle_item()")
         self.selections[index] = not self.selections[index]
-        self.draw_screen(self.indexed_items, self.highlights)
+        self.draw_screen()
 
     def select_all(self) -> None:
         """ Select all in indexed_items. """
@@ -1818,7 +2154,7 @@ class Picker:
             self.cell_selections[i] = True
         for row in range(len(self.indexed_items)):
             self.selected_cells_by_row[row] = list(range(len(self.indexed_items[row][1])))
-        self.draw_screen(self.indexed_items, self.highlights)
+        self.draw_screen()
 
     def deselect_all(self) -> None:
         """ Deselect all items in indexed_items. """
@@ -1828,7 +2164,7 @@ class Picker:
         for i in self.cell_selections.keys():
             self.cell_selections[i] = False
         self.selected_cells_by_row = {}
-        self.draw_screen(self.indexed_items, self.highlights)
+        self.draw_screen()
 
     def handle_visual_selection(self, selecting:bool = True) -> None:
         """ Toggle visual selection or deselection. """
@@ -1872,7 +2208,7 @@ class Picker:
             self.end_selection = -1
             self.is_selecting = False
 
-            self.draw_screen(self.indexed_items, self.highlights)
+            self.draw_screen()
 
         elif self.is_deselecting:
             self.end_selection = self.indexed_items[self.cursor_pos][0]
@@ -1905,7 +2241,7 @@ class Picker:
             self.start_selection = -1
             self.end_selection = -1
             self.is_deselecting = False
-            self.draw_screen(self.indexed_items, self.highlights)
+            self.draw_screen()
 
     def cursor_down(self, count=1) -> bool:
         """ Move cursor down. """
@@ -1919,6 +2255,7 @@ class Picker:
             if self.indexed_items[new_pos][0] in self.unselectable_indices: new_pos+=1
             else: break
         self.cursor_pos = new_pos
+        self.ensure_no_overscroll()
         return True
 
     def cursor_up(self, count=1) -> bool:
@@ -1932,6 +2269,7 @@ class Picker:
             elif new_pos in self.unselectable_indices: new_pos -= 1
             else: break
         self.cursor_pos = new_pos
+        self.ensure_no_overscroll()
         return True
 
     def remapped_key(self, key: int, val: int, key_remappings: dict) -> bool:
@@ -1953,6 +2291,19 @@ class Picker:
             return True
         return False
 
+    def check_and_run_macro(self, key: int) -> bool:
+        macro_match = False
+        for macro in self.macros:
+            try:
+                if key in macro["keys"]:
+                    macro_match = True
+                    macro["function"](self)
+                    break
+            except:
+                pass
+        return macro_match
+
+
     def copy_dialogue(self) -> None:
         """ Display dialogue to select how rows/cells should be copied. """
         self.logger.info(f"function: copy_dialogue()")
@@ -2023,12 +2374,12 @@ class Picker:
                     if not acceptable_data_type:
                         break
                 if not acceptable_data_type:
-                    self.draw_screen(self.indexed_items, self.highlights)
+                    self.draw_screen()
                     self.notification(self.stdscr, message="Error pasting data.")
                     return None
 
         except:
-            self.draw_screen(self.indexed_items, self.highlights)
+            self.draw_screen()
             self.notification(self.stdscr, message="Error pasting data.")
             return None
         if type(pasta) == type([]) and len(pasta) > 0 and type(pasta[0]) == type([]):
@@ -2075,7 +2426,7 @@ class Picker:
             for idx in s.keys():
                 save_path_entered, save_path = output_file_option_selector(
                     self.stdscr,
-                    refresh_screen_function=lambda: self.draw_screen(self.indexed_items, self.highlights)
+                    refresh_screen_function=lambda: self.draw_screen()
                 )
                 if save_path_entered:
                     return_val = funcs[idx](save_path)
@@ -2109,7 +2460,7 @@ class Picker:
                 self.loaded_file_states[self.loaded_file_index] = self.get_function_data()
 
                 self.stdscr.clear()
-                self.draw_screen(self.indexed_items, self.highlights)
+                self.draw_screen()
 
                 tmp = self.stdscr
 
@@ -2121,7 +2472,7 @@ class Picker:
 
                 self.stdscr = tmp
 
-                self.notification(self.stdscr, f"{repr(file_to_load)} has been loaded!")
+                # self.notification(self.stdscr, f"{repr(file_to_load)} has been loaded!")
 
                 self.set_function_data({}, reset_absent_variables=True)
                 self.load_file(self.loaded_file)
@@ -2129,7 +2480,7 @@ class Picker:
                 # header = return_val["header"]
                 self.stdscr.clear()
                 # self.initialise_variables()
-                self.draw_screen(self.indexed_items, self.highlights)
+                self.draw_screen()
                 # self.stdscr.refresh()
 
                 # if return_val:
@@ -2144,7 +2495,15 @@ class Picker:
     def fetch_data(self) -> None:
         """ Refesh data asynchronously. When data has been fetched self.data_ready is set to True. """
         self.logger.info(f"function: fetch_data()")
-        tmp_items, tmp_header = self.refresh_function()
+        tmp_items, tmp_header = [], []
+        self.getting_data.clear()
+        self.refresh_function(
+            tmp_items, 
+            tmp_header, 
+            self.visible_rows_indices, 
+            self.getting_data,
+            self.get_function_data(),
+        )
         if self.track_entries_upon_refresh:
             selected_indices = get_selected_indices(self.selections)
             self.ids = [item[self.id_column] for i, item in enumerate(self.items) if i in selected_indices]
@@ -2242,10 +2601,6 @@ class Picker:
             row_len = 1
             if self.header: row_len = len(self.header)
             elif len(self.items): row_len  = len(self.items[0])
-            # if len(self.indexed_items) == 0:
-            #     insert_at_pos = 0
-            # else:
-            #     insert_at_pos = self.indexed_items[self.cursor_pos][0]
             self.items = self.items[:pos] + [["" for x in range(row_len)]] + self.items[pos:]
             if pos <= self.cursor_pos:
                 self.cursor_pos += 1
@@ -2355,27 +2710,99 @@ class Picker:
             self.split_right = not self.split_right
             if self.right_panes[self.right_pane_index]["data"] in [[], None, {}]:
                 self.right_panes[self.right_pane_index]["data"] = self.right_panes[self.right_pane_index]["get_data"](self.right_panes[self.right_pane_index]["data"], self.get_function_data())
+        self.ensure_no_overscroll()
+
+    def toggle_left_pane(self):
+        if len(self.left_panes):
+            self.split_left = not self.split_left
+            if self.left_panes[self.left_pane_index]["data"] in [[], None, {}]:
+                self.left_panes[self.left_pane_index]["data"] = self.left_panes[self.left_pane_index]["get_data"](self.left_panes[self.left_pane_index]["data"], self.get_function_data())
+        self.ensure_no_overscroll()
 
 
     def cycle_right_pane(self, increment=1):
         if len(self.right_panes) > 1:
             self.right_pane_index = (self.right_pane_index+1)%len(self.right_panes)
-            self.initial_split_time = self.initial_split_time - self.right_panes[self.right_pane_index]["refresh_time"]
+            self.initial_right_split_time -= self.right_panes[self.right_pane_index]["refresh_time"]
+        self.ensure_no_overscroll()
+
+    def cycle_left_pane(self, increment=1):
+        if len(self.left_panes) > 1:
+            self.left_pane_index = (self.left_pane_index+1)%len(self.left_panes)
+            self.initial_left_split_time -= self.left_panes[self.left_pane_index]["refresh_time"]
+        self.ensure_no_overscroll()
+
+    def ensure_no_overscroll(self):
+        """ 
+        Ensure that we haven't scrolled past the last column.
+
+        This check should be performed after:
+          - Terminal resize event
+          - Scrolling down - i.e., rows with potentially different widths come into view
+        """
+        self.calculate_section_sizes()
+        self.get_visible_rows()
+        self.column_widths = get_column_widths(
+            self.visible_rows,
+            header=self.header,
+            max_column_width=self.max_column_width,
+            number_columns=self.number_columns,
+            max_total_width=self.rows_w,
+            unicode_char_width=self.unicode_char_width
+        )
+        self.calculate_section_sizes()
+
+        row_width = sum(self.visible_column_widths) + len(self.separator)*(len(self.visible_column_widths)-1)
+        if row_width - self.leftmost_char < self.rows_w:
+            if row_width <= self.rows_w - self.left_gutter_width:
+                self.leftmost_char = 0
+            else:
+                self.leftmost_char = row_width - (self.rows_w - self.left_gutter_width) + 5
+
+    def cleanup_processes(self):
+        self.thread_stop_event.set()
+        self.data_generation_queue.clear()
+        # with self.data_generation_queue.mutex:
+        #     self.data_generation_queue.queue.clear()
+        function_data = self.get_function_data()
+        for proc in self.processes:
+            if proc.is_alive():
+                proc.terminate()
+                proc.join(timeout=0.01)
+        self.processes = []
+        self.items_sync_loop_event.set()
+        if self.items_sync_thread != None:
+            self.items_sync_thread.join(timeout=1)
+
+    def cleanup_threads(self):
+        self.thread_stop_event.set()
+        with self.data_generation_queue.mutex:
+            self.data_generation_queue.queue.clear()
+        function_data = self.get_function_data()
+        for t in self.threads:
+            if t.is_alive():
+                t.join(timeout=0.01)
 
     def run(self) -> Tuple[list[int], str, dict]:
         """ Run the picker. """
         self.logger.info(f"function: run()")
 
+        self.thread_stop_event.clear()
+
         if self.get_footer_string_startup and self.footer_string_refresh_function != None:
+            self.footer_string = " "
+            self.footer.adjust_sizes(self.term_h, self.term_w)
+            self.draw_screen()
             self.footer_string = self.footer_string_refresh_function()
 
         self.initialise_variables(get_data=self.get_data_startup)
 
-        self.draw_screen(self.indexed_items, self.highlights)
+        self.draw_screen()
 
         self.initial_time = time.time()
         self.initial_time_footer = time.time()-self.footer_timer
-        self.initial_split_time = time.time()-200
+        self.initial_right_split_time = time.time()-200
+        self.initial_left_split_time = time.time()-200
 
         if self.startup_notification:
             self.notification(self.stdscr, message=self.startup_notification)
@@ -2399,7 +2826,7 @@ class Picker:
 
         # Set terminal background color
         self.stdscr.bkgd(' ', curses.color_pair(self.colours_start+3))  # Apply background color
-        self.draw_screen(self.indexed_items, self.highlights)
+        self.draw_screen()
 
         if self.display_only:
             self.stdscr.refresh()
@@ -2407,21 +2834,21 @@ class Picker:
             return [], "", function_data
 
         # Open tty to accept input
-        tty_fd = open_tty()
+        tty_fd, self.saved_terminal_state = open_tty()
+
+        self.update_term_size()
+        self.calculate_section_sizes()
 
-        h, w = self.stdscr.getmaxyx()
-        self.term_h, self.term_w = self.stdscr.getmaxyx()
-        if self.split_right and len(self.right_panes):
-            proportion = self.right_panes[self.right_pane_index]["proportion"]
-            self.rows_w, self.rows_h = int(self.term_w*proportion), self.term_h
-        else:
-            self.rows_w, self.rows_h = self.term_w, self.term_h
         def terminal_resized(old_w, old_h) -> bool:
             w, h = os.get_terminal_size()
             if old_h != h or old_w != w: return True
             else: return False
 
         COLS, LINES = os.get_terminal_size()
+
+
+        getting_data_prev = False
+
         # Main loop
         while True:
             # key = self.stdscr.getch()
@@ -2429,21 +2856,23 @@ class Picker:
             key = get_char(tty_fd, timeout=0.2)
             if key != -1:
                 self.logger.info(f"key={key}")
+                self.last_key = key
+
+            # Ensure that
+
+            if not self.getting_data.is_set():
+                self.initialise_variables()
+                getting_data_prev = True
+            elif getting_data_prev:
+                ## Ensure that we reinitialise one final time after all data is retrieved.
+                self.initialise_variables()
+                getting_data_prev = False
 
             self.term_resize_event = terminal_resized(COLS, LINES)
             COLS, LINES = os.get_terminal_size()
             if self.term_resize_event: 
                 key = curses.KEY_RESIZE
 
-            h, w = self.stdscr.getmaxyx()
-            self.term_h, self.term_w = self.stdscr.getmaxyx()
-
-            if self.split_right and len(self.right_panes):
-                proportion = self.right_panes[self.right_pane_index]["proportion"]
-                self.rows_w, self.rows_h = int(self.term_w*proportion), self.term_h
-            else:
-                self.rows_w, self.rows_h = self.term_w, self.term_h
-
             if key in self.disabled_keys: continue
             clear_screen=True
 
@@ -2457,16 +2886,20 @@ class Picker:
 
                         self.initial_time = time.time()
 
-                        self.draw_screen(self.indexed_items, self.highlights, clear=False)
+                        self.draw_screen(clear=False)
 
                         self.refreshing_data = False
                         self.data_ready = False
 
+
             elif self.check_key("refresh", key, self.keys_dict) or self.remapped_key(key, curses.KEY_F5, self.key_remappings) or (self.auto_refresh and (time.time() - self.initial_time) >= self.timer):
                 self.logger.debug(f"Get new data (refresh).")
-                self.stdscr.addstr(0,self.term_w-3,"  ", curses.color_pair(self.colours_start+21) | curses.A_BOLD)
+                try:
+                    self.stdscr.addstr(0,self.term_w-3,"  ", curses.color_pair(self.colours_start+21) | curses.A_BOLD)
+                except:
+                    pass
                 self.stdscr.refresh()
-                if self.get_new_data and self.refresh_function:
+                if self.get_new_data:
                     self.refreshing_data = True
 
                     t = threading.Thread(target=self.fetch_data)
@@ -2493,13 +2926,19 @@ class Picker:
                 self.logger.debug(f"footer_string_auto_refresh")
                 self.footer_string = self.footer_string_refresh_function()
                 self.initial_time_footer = time.time()
-                self.draw_screen(self.indexed_items, self.highlights)
+                self.draw_screen()
 
-            if self.split_right and len(self.right_panes) and self.right_panes[self.right_pane_index]["auto_refresh"] and ((time.time() - self.initial_split_time) > self.right_panes[self.right_pane_index]["refresh_time"]):
+            if self.split_right and len(self.right_panes) and self.right_panes[self.right_pane_index]["auto_refresh"] and ((time.time() - self.initial_right_split_time) > self.right_panes[self.right_pane_index]["refresh_time"]):
                 get_data = self.right_panes[self.right_pane_index]["get_data"]
                 data = self.right_panes[self.right_pane_index]["data"]
                 self.right_panes[self.right_pane_index]["data"] = get_data(data, self.get_function_data())
-                self.initial_split_time = time.time()
+                self.initial_right_split_time = time.time()
+
+            if self.split_left and len(self.left_panes) and self.left_panes[self.left_pane_index]["auto_refresh"] and ((time.time() - self.initial_left_split_time) > self.left_panes[self.left_pane_index]["refresh_time"]):
+                get_data = self.left_panes[self.left_pane_index]["get_data"]
+                data = self.left_panes[self.left_pane_index]["data"]
+                self.left_panes[self.right_pane_index]["data"] = get_data(data, self.get_function_data())
+                self.initial_left_split_time = time.time()
 
             if self.check_key("help", key, self.keys_dict):
                 self.logger.info(f"key_function help")
@@ -2507,7 +2946,7 @@ class Picker:
                 self.stdscr.refresh()
                 help_data = {
                     # "items": help_lines,
-                    "items": build_help_rows(self.keys_dict),
+                    "items": build_help_rows(self.keys_dict, self.macros),
                     "title": f"{self.title} Help",
                     "colours_start": self.help_colours_start,
                     "colours": help_colours,
@@ -2529,7 +2968,11 @@ class Picker:
                 }
                 OptionPicker = Picker(self.stdscr, **help_data)
                 s, o, f = OptionPicker.run()
-                self.draw_screen(self.indexed_items, self.highlights)
+                self.draw_screen()
+
+            if self.check_and_run_macro(key):
+                self.draw_screen()
+                continue
 
             if self.check_key("info", key, self.keys_dict):
                 self.logger.info(f"key_function help")
@@ -2603,6 +3046,14 @@ class Picker:
                 data["option_functions"] = f"[...] length = {len(data['option_functions'])}"
                 data["loaded_file_states"] = f"[...] length = {len(data['loaded_file_states'])}"
                 data["sheet_states"] = f"[...] length = {len(data['sheet_states'])}"
+                data["highlights"] = f"[...] length = {len(data['highlights'])}"
+                data["colours"] = f"[...] length = {len(data['colours'])}"
+                data["keys_dict"] = f"[...] length = {len(data['keys_dict'])}"
+                data["history_filter_and_search"] = f"[...] length = {len(data['history_filter_and_search'])}"
+                data["history_opts"] = f"[...] length = {len(data['history_opts'])}"
+                data["history_edits"] = f"[...] length = {len(data['history_edits'])}"
+                data["history_pipes"] = f"[...] length = {len(data['history_pipes'])}"
+                data["history_settings"] = f"[...] length = {len(data['history_settings'])}"
                 info_items += [
                     ["",""],
                     ["  get_function_data()", "-*"*30],
@@ -2643,13 +3094,14 @@ class Picker:
                 OptionPicker = Picker(self.stdscr, **info_data)
                 s, o, f = OptionPicker.run()
                 
-                self.draw_screen(self.indexed_items, self.highlights)
+                self.draw_screen()
 
             elif self.check_key("exit", key, self.keys_dict):
                 self.stdscr.clear()
                 if len(self.loaded_files) <= 1:
+                    self.cleanup_threads()
                     function_data = self.get_function_data()
-                    function_data["last_key"] = key
+                    restore_terminal_settings(tty_fd, self.saved_terminal_state)
                     return [], "", function_data
                 else:
                     del self.loaded_files[self.loaded_file_index]
@@ -2666,28 +3118,30 @@ class Picker:
                         self.set_function_data({}, reset_absent_variables=True)
                         self.load_file(self.loaded_file)
                     self.loaded_file_index, self.loaded_file = idx, file
-                    self.draw_screen(self.indexed_items, self.highlights)
+                    self.draw_screen()
 
             elif self.check_key("full_exit", key, self.keys_dict):
+                self.cleanup_threads()
                 close_curses(self.stdscr)
+                restore_terminal_settings(tty_fd, self.saved_terminal_state)
                 exit()
 
             elif self.check_key("settings_input", key, self.keys_dict):
                 self.logger.info(f"Settings input")
                 usrtxt = f"{self.user_settings.strip()} " if self.user_settings else ""
-                field_end_f = lambda: self.stdscr.getmaxyx()[1]-38 if self.show_footer else lambda: self.stdscr.getmaxyx()[1]-3
-                if self.show_footer and self.footer.height >= 2: field_end_f = lambda: self.stdscr.getmaxyx()[1]-38
-                else: field_end_f = lambda: self.stdscr.getmaxyx()[1]-3
+                field_end_f = lambda: self.get_term_size()[1]-38 if self.show_footer else lambda: self.get_term_size()[1]-3
+                if self.show_footer and self.footer.height >= 2: field_end_f = lambda: self.get_term_size()[1]-38
+                else: field_end_f = lambda: self.get_term_size()[1]-3
                 self.set_registers()
                 usrtxt, return_val = input_field(
                     self.stdscr,
                     usrtxt=usrtxt,
                     field_prefix=" Settings: ",
                     x=lambda:2,
-                    y=lambda: self.stdscr.getmaxyx()[0]-1,
+                    y=lambda: self.get_term_size()[0]-1,
                     max_length=field_end_f,
                     registers=self.registers,
-                    refresh_screen_function=lambda: self.draw_screen(self.indexed_items, self.highlights),
+                    refresh_screen_function=lambda: self.draw_screen(),
                     history=self.history_settings,
                     path_auto_complete=True,
                     formula_auto_complete=False,
@@ -2707,28 +3161,29 @@ class Picker:
 
             elif self.check_key("settings_options", key, self.keys_dict):
                 options = []
+                options += [["cv", "Centre rows vertically"]]
+                options += [["pc", "Pin cursor to row index during data refresh."]]
+                options += [["ct", "Centre column-set in terminal"]]
+                options += [["cc", "Centre values in cells"]]
+                options += [["!r", "Toggle auto-refresh"]]
+                options += [["th", "Cycle between themes. (accepts th#)"]]
+                options += [["colsel", "Toggle columns."]]
+                options += [["nohl", "Toggle highlights"]]
+                options += [["footer", "Toggle footer"]]
+                options += [["header", "Toggle header"]]
+                options += [["rh", "Toggle row header"]]
+                options += [["modes", "Toggle modes"]]
+                options += [["ft", "Cycle through footer styles (accepts ft#)"]]
+                options += [["file_next", "Go to the next open file."]]
+                options += [["file_prev", "Go to the previous open file."]]
+                options += [["sheet_next", "Go to the next sheet."]]
+                options += [["sheet_prev", "Go to the previous sheet."]]
+                options += [["unicode", "Toggle b/w using len and wcwidth to calculate char width."]]
+                options += [["ara", "Add empty row after cursor."]]
+                options += [["arb", "Add empty row before the cursor."]]
+                options += [["aca", "Add empty column after the selected column."]]
+                options += [["acb", "Add empty column before the selected column."]]
                 if len(self.items) > 0:
-                    options += [["cv", "Centre rows vertically"]]
-                    options += [["pc", "Pin cursor to row number when data refreshes"]]
-                    options += [["ct", "Centre column-set in terminal"]]
-                    options += [["cc", "Centre values in cells"]]
-                    options += [["!r", "Toggle auto-refresh"]]
-                    options += [["th", "Cycle between themes. (accepts th#)"]]
-                    options += [["nohl", "Toggle highlights"]]
-                    options += [["footer", "Toggle footer"]]
-                    options += [["header", "Toggle header"]]
-                    options += [["rh", "Toggle row header"]]
-                    options += [["modes", "Toggle modes"]]
-                    options += [["ft", "Cycle through footer styles (accepts ft#)"]]
-                    options += [["file_next", "Go to the next open file."]]
-                    options += [["file_prev", "Go to the previous open file."]]
-                    options += [["sheet_next", "Go to the next sheet."]]
-                    options += [["sheet_prev", "Go to the previous sheet."]]
-                    options += [["unicode", "Toggle b/w using len and wcwidth to calculate char width."]]
-                    options += [["ara", "Add empty row after cursor."]]
-                    options += [["arb", "Add empty row before the cursor."]]
-                    options += [["aca", "Add empty column after the selected column."]]
-                    options += [["acb", "Add empty column before the selected column."]]
                     options += [[f"col{i}", f"Select column {i}"] for i in range(len(self.items[0]))]
                     options += [[f"s{i}", f"Sort by column {i}"] for i in range(len(self.items[0]))]
                     options += [[f"!{i}", f"Toggle visibility of column {i}"] for i in range(len(self.items[0]))]
@@ -2743,6 +3198,7 @@ class Picker:
 
             elif self.check_key("redo", key, self.keys_dict):
                 self.redo()
+
             # elif self.check_key("move_column_left", key, self.keys_dict):
             #     tmp1 = self.column_indices[self.selected_column]
             #     tmp2 = self.column_indices[(self.selected_column-1)%len(self.column_indices)]
@@ -2752,7 +3208,7 @@ class Picker:
             #     # self.notification(self.stdscr, f"{str(self.column_indices)}, {tmp1}, {tmp2}")
             #     self.initialise_variables()
             #     self.column_widths = get_column_widths([v[1] for v in self.indexed_items], header=self.header, max_column_width=self.max_column_width, number_columns=self.number_columns, max_total_width=w)
-            #     self.draw_screen(self.indexed_items, self.highlights)
+            #     self.draw_screen()
             #     # self.move_column(direction=-1)
             #
             # elif self.check_key("move_column_right", key, self.keys_dict):
@@ -2762,7 +3218,7 @@ class Picker:
             #     self.column_indices[(self.selected_column+1)%(len(self.column_indices))] = tmp1
             #     self.selected_column = (self.selected_column+1)%len(self.column_indices)
             #     self.initialise_variables()
-            #     self.draw_screen(self.indexed_items, self.highlights)
+            #     self.draw_screen()
             #     # self.move_column(direction=1)
 
             elif self.check_key("cursor_down", key, self.keys_dict):
@@ -2816,6 +3272,7 @@ class Picker:
                             self.selected_cells_by_row[row] = [col]
 
                 self.cursor_down()
+                self.ensure_no_overscroll()
             elif self.check_key("select_all", key, self.keys_dict):  # Select all (m or ctrl-a)
                 self.select_all()
 
@@ -2830,7 +3287,8 @@ class Picker:
                 if new_pos < len(self.indexed_items):
                     self.cursor_pos = new_pos
 
-                self.draw_screen(self.indexed_items, self.highlights)
+                self.ensure_no_overscroll()
+                self.draw_screen()
 
             elif self.check_key("cursor_bottom", key, self.keys_dict):
                 new_pos = len(self.indexed_items)-1
@@ -2839,19 +3297,17 @@ class Picker:
                     else: break
                 if new_pos < len(self.items) and new_pos >= 0:
                     self.cursor_pos = new_pos
-                self.draw_screen(self.indexed_items, self.highlights)
-                # current_row = items_per_page - 1
-                # if current_page + 1 == (len(self.indexed_items) + items_per_page - 1) // items_per_page:
-                #
-                #     current_row = (len(self.indexed_items) +items_per_page - 1) % items_per_page
-                # self.draw_screen(self.indexed_items, self.highlights)
+                self.ensure_no_overscroll()
+                self.draw_screen()
+
             elif self.check_key("enter", key, self.keys_dict):
                 self.logger.info(f"key_function enter")
                 # Print the selected indices if any, otherwise print the current index
                 if self.is_selecting or self.is_deselecting: self.handle_visual_selection()
                 if len(self.items) == 0:
+                    self.cleanup_threads()
                     function_data = self.get_function_data()
-                    function_data["last_key"] = key
+                    restore_terminal_settings(tty_fd, self.saved_terminal_state)
                     return [], "", function_data
                 selected_indices = get_selected_indices(self.selections)
                 if not selected_indices and len(self.indexed_items):
@@ -2864,8 +3320,7 @@ class Picker:
                         if self.option_functions[index] != None:
                             options_sufficient, usrtxt = self.option_functions[index](
                                 stdscr=self.stdscr,
-                                refresh_screen_function=lambda: self.draw_screen(self.indexed_items, self.highlights),
-                                field_prefix=f" Opts ({index}): ",
+                                refresh_screen_function=lambda: self.draw_screen(),
                             )
                         else:
                             self.set_registers()
@@ -2877,11 +3332,12 @@ class Picker:
                             )
 
                 if options_sufficient:
+                    self.cleanup_threads()
                     self.user_opts = usrtxt
                     self.stdscr.clear()
                     self.stdscr.refresh()
                     function_data = self.get_function_data()
-                    function_data["last_key"] = key
+                    restore_terminal_settings(tty_fd, self.saved_terminal_state)
                     return selected_indices, usrtxt, function_data
             elif self.check_key("page_down", key, self.keys_dict):  # Next page
                 self.cursor_pos = min(len(self.indexed_items) - 1, self.cursor_pos+self.items_per_page)
@@ -2890,15 +3346,7 @@ class Picker:
                 self.cursor_pos = max(0, self.cursor_pos-self.items_per_page)
 
             elif self.check_key("redraw_screen", key, self.keys_dict):
-                self.logger.info(f"key_function redraw_screen")
-                self.stdscr.clear()
-                self.stdscr.refresh()
-                restrict_curses(self.stdscr)
-                unrestrict_curses(self.stdscr)
-                self.stdscr.clear()
-                self.stdscr.refresh()
-
-                self.draw_screen(self.indexed_items, self.highlights)
+                self.refresh_and_draw_screen()
 
             elif self.check_key("cycle_sort_method", key, self.keys_dict):
                 if self.sort_column == self.selected_column:
@@ -2926,7 +3374,7 @@ class Picker:
                 if len(self.indexed_items) > 0:
                     current_index = self.indexed_items[self.cursor_pos][0]
                     sort_items(self.indexed_items, sort_method=self.columns_sort_method[self.sort_column], sort_column=self.sort_column, sort_reverse=self.sort_reverse[self.sort_column])  # Re-sort self.items based on new column
-                    self.draw_screen(self.indexed_items, self.highlights)
+                    self.draw_screen()
                     self.cursor_pos = [row[0] for row in self.indexed_items].index(current_index)
                 self.logger.info(f"key_function cycle_sort_order. (sort_column, sort_method, sort_reverse) = ({self.sort_column}, {self.columns_sort_method[self.sort_column]}, {self.sort_reverse[self.sort_column]})")
             elif self.check_key("col_select", key, self.keys_dict):
@@ -2939,23 +3387,29 @@ class Picker:
                         sort_items(self.indexed_items, sort_method=self.columns_sort_method[self.sort_column], sort_column=self.sort_column, sort_reverse=self.sort_reverse[self.sort_column])  # Re-sort self.items based on new column
                         self.cursor_pos = [row[0] for row in self.indexed_items].index(current_index)
             elif self.check_key("col_select_next", key, self.keys_dict):
-                if len(self.items) > 0 and len(self.items[0]) > 0:
-                    col_index = (self.selected_column +1) % (len(self.items[0]))
-                    self.selected_column = col_index
-                # Flash when we loop back to the first column
-                # if self.selected_column == 0:
-                #     curses.flash()
                 self.logger.info(f"key_function col_select_next {self.selected_column}")
+                if len(self.hidden_columns) != len(self.column_widths):
+                    if len(self.column_widths):
+                        while True:
+                            self.hidden_columns
+                            col_index = (self.selected_column +1) % (len(self.column_widths))
+                            self.selected_column = col_index
+                            if self.selected_column not in self.hidden_columns:
+                                break
+
+                    # Flash when we loop back to the first column
+                    # if self.selected_column == 0:
+                    #     curses.flash()
 
 
                 ## Scroll with column select
-                rows = self.get_visible_rows()
-                self.column_widths = get_column_widths(rows, header=self.header, max_column_width=self.max_column_width, number_columns=self.number_columns, max_total_width=self.rows_w, unicode_char_width=self.unicode_char_width)
-                visible_column_widths = [c for i,c in enumerate(self.column_widths) if i not in self.hidden_columns]
-                column_set_width = sum(visible_column_widths)+len(self.separator)*len(visible_column_widths)
-                start_of_cell = sum(visible_column_widths[:self.selected_column])+len(self.separator)*self.selected_column
-                end_of_cell = sum(visible_column_widths[:self.selected_column+1])+len(self.separator)*(self.selected_column+1)
-                display_width = self.rows_w-self.startx
+                self.get_visible_rows()
+                self.column_widths = get_column_widths(self.visible_rows, header=self.header, max_column_width=self.max_column_width, number_columns=self.number_columns, max_total_width=self.rows_w, unicode_char_width=self.unicode_char_width)
+                self.visible_column_widths = [c for i,c in enumerate(self.column_widths) if i not in self.hidden_columns]
+                column_set_width = sum(self.visible_column_widths)+len(self.separator)*len(self.visible_column_widths)
+                start_of_cell = sum(self.visible_column_widths[:self.selected_column])+len(self.separator)*self.selected_column
+                end_of_cell = sum(self.visible_column_widths[:self.selected_column+1])+len(self.separator)*(self.selected_column+1)
+                display_width = self.rows_w-self.left_gutter_width
                 # If the full column is within the current display then don't do anything
                 if start_of_cell >= self.leftmost_char and end_of_cell <= self.leftmost_char + display_width:
                     pass
@@ -2964,25 +3418,32 @@ class Picker:
                     self.leftmost_char = end_of_cell - display_width
 
                 self.leftmost_char = max(0, min(column_set_width - display_width + 5, self.leftmost_char))
+                self.ensure_no_overscroll()
 
             elif self.check_key("col_select_prev", key, self.keys_dict):
-                if len(self.items) > 0 and len(self.items[0]) > 0:
-                    col_index = (self.selected_column -1) % (len(self.items[0]))
-                    self.selected_column = col_index
-
                 self.logger.info(f"key_function col_select_prev {self.selected_column}")
+
+                if len(self.hidden_columns) != len(self.column_widths):
+                    if len(self.column_widths):
+                        while True:
+                            self.hidden_columns
+                            col_index = (self.selected_column -1) % (len(self.column_widths))
+                            self.selected_column = col_index
+                            if self.selected_column not in self.hidden_columns:
+                                break
+
                 # Flash when we loop back to the last column
                 # if self.selected_column == len(self.column_widths)-1:
                 #     curses.flash()
 
                 ## Scroll with column select
-                rows = self.get_visible_rows()
-                self.column_widths = get_column_widths(rows, header=self.header, max_column_width=self.max_column_width, number_columns=self.number_columns, max_total_width=self.rows_w, unicode_char_width=self.unicode_char_width)
-                visible_column_widths = [c for i,c in enumerate(self.column_widths) if i not in self.hidden_columns]
-                column_set_width = sum(visible_column_widths)+len(self.separator)*len(visible_column_widths)
-                start_of_cell = sum(visible_column_widths[:self.selected_column])+len(self.separator)*self.selected_column
-                end_of_cell = sum(visible_column_widths[:self.selected_column+1])+len(self.separator)*(self.selected_column+1)
-                display_width = self.rows_w-self.startx
+                self.get_visible_rows()
+                self.column_widths = get_column_widths(self.visible_rows, header=self.header, max_column_width=self.max_column_width, number_columns=self.number_columns, max_total_width=self.rows_w, unicode_char_width=self.unicode_char_width)
+                self.visible_column_widths = [c for i,c in enumerate(self.column_widths) if i not in self.hidden_columns]
+                column_set_width = sum(self.visible_column_widths)+len(self.separator)*len(self.visible_column_widths)
+                start_of_cell = sum(self.visible_column_widths[:self.selected_column])+len(self.separator)*self.selected_column
+                end_of_cell = sum(self.visible_column_widths[:self.selected_column+1])+len(self.separator)*(self.selected_column+1)
+                display_width = self.rows_w-self.left_gutter_width
 
                 # If the entire column is within the current display then don't do anything
                 if start_of_cell >= self.leftmost_char and end_of_cell <= self.leftmost_char + display_width:
@@ -2992,25 +3453,26 @@ class Picker:
                     self.leftmost_char = start_of_cell
 
                 self.leftmost_char = max(0, min(column_set_width - display_width + 5, self.leftmost_char))
+                self.ensure_no_overscroll()
 
             elif self.check_key("scroll_right", key, self.keys_dict):
                 self.logger.info(f"key_function scroll_right")
                 if len(self.indexed_items):
-                    row_width = sum(self.column_widths) + len(self.separator)*(len(self.column_widths)-1)
-                    if row_width-self.leftmost_char >= self.rows_w-self.startx-5:
+                    row_width = sum(self.visible_column_widths) + len(self.separator)*(len(self.visible_column_widths)-1)
+                    if row_width-self.leftmost_char >= self.rows_w-5:
                         self.leftmost_char += 5
-                    self.leftmost_char = min(self.leftmost_char, row_width - (self.rows_w - self.startx) + 5)
-                if sum(self.column_widths) + len(self.column_widths)*len(self.separator) < self.rows_w:
+                    self.leftmost_char = min(self.leftmost_char, row_width - (self.rows_w) + self.left_gutter_width+5)
+                if sum(self.visible_column_widths) + len(self.visible_column_widths)*len(self.separator) < self.rows_w:
                     self.leftmost_char = 0
 
             elif self.check_key("scroll_right_25", key, self.keys_dict):
                 self.logger.info(f"key_function scroll_right")
                 if len(self.indexed_items):
-                    row_width = sum(self.column_widths) + len(self.separator)*(len(self.column_widths)-1)
-                    if row_width-self.leftmost_char >= self.rows_w-self.startx-25:
+                    row_width = sum(self.visible_column_widths) + len(self.separator)*(len(self.visible_column_widths)-1)
+                    if row_width-self.leftmost_char+5 >= self.rows_w-25:
                         self.leftmost_char += 25
-                    self.leftmost_char = min(self.leftmost_char, row_width - (self.rows_w - self.startx) + 5)
-                if sum(self.column_widths) + len(self.column_widths)*len(self.separator) < self.rows_w:
+                    self.leftmost_char = min(self.leftmost_char, row_width - (self.rows_w) + self.left_gutter_width+5)
+                if sum(self.visible_column_widths) + len(self.visible_column_widths)*len(self.separator) < self.rows_w:
                     self.leftmost_char = 0
 
             elif self.check_key("scroll_left", key, self.keys_dict):
@@ -3029,20 +3491,14 @@ class Picker:
             elif self.check_key("scroll_far_right", key, self.keys_dict):
                 self.logger.info(f"key_function scroll_far_right")
                 longest_row_str_len = 0
-                # rows = self.get_visible_rows()
-                # for i in range(len(rows)):
-                #     item = rows[i]
-                #     row_str = format_row(item, self.hidden_columns, self.column_widths, self.separator, self.centre_in_cols, self.unicode_char_width)
-                #     if len(row_str) > longest_row_str_len: longest_row_str_len=len(row_str)
-                longest_row_str_len = sum(self.column_widths) + (len(self.column_widths)-1)*len(self.separator)
-                # for i in range(len(self.indexed_items)):
-                #     item = self.indexed_items[i]
-                #     row_str = format_row(item[1], self.hidden_columns, self.column_widths, self.separator, self.centre_in_cols)
-                #     if len(row_str) > longest_row_str_len: longest_row_str_len=len(row_str)
-                # self.notification(self.stdscr, f"{longest_row_str_len}")
-                self.leftmost_char = max(0, longest_row_str_len-self.rows_w+2+self.startx+5)
-                if len(self.items):
-                    self.selected_column = len(self.items[0])-1
+                longest_row_str_len = sum(self.visible_column_widths) + (len(self.visible_column_widths)-1)*len(self.separator)
+                if len(self.column_widths):
+                    row_width = sum(self.visible_column_widths) + len(self.separator)*(len(self.visible_column_widths)-1)
+                    self.leftmost_char = row_width - (self.rows_w) + self.left_gutter_width+5
+                    self.leftmost_char = min(self.leftmost_char, row_width - (self.rows_w) + self.left_gutter_width+5)
+
+                    longest_row_str_len = sum(self.visible_column_widths) + (len(self.visible_column_widths)-1)*len(self.separator)
+                    self.selected_column = len(self.column_widths)-1
 
             elif self.check_key("add_column_before", key, self.keys_dict):
                 self.logger.info(f"key_function add_column_before")
@@ -3099,52 +3555,45 @@ class Picker:
                     self.selected_column = min(self.selected_column, row_len-2)
                 self.initialise_variables()
 
-
-
-
-            # elif self.check_key("increase_lines_per_page", key, self.keys_dict):
-            #     self.items_per_page += 1
-            #     self.draw_screen(self.indexed_items, self.highlights)
-            # elif self.check_key("decrease_lines_per_page", key, self.keys_dict):
-            #     if self.items_per_page > 1:
-            #         self.items_per_page -= 1
-            #     self.draw_screen(self.indexed_items, self.highlights)
             elif self.check_key("decrease_column_width", key, self.keys_dict):
                 self.logger.info(f"key_function decrease_column_width")
                 if self.max_column_width > 10:
                     self.max_column_width -= 10
                     # self.column_widths = get_column_widths(self.items, header=self.header, max_column_width=self.max_column_width, number_columns=self.number_columns, max_total_width=2)
-                    self.draw_screen(self.indexed_items, self.highlights)
+                    self.draw_screen()
             elif self.check_key("increase_column_width", key, self.keys_dict):
                 self.logger.info(f"key_function increase_column_width")
                 if self.max_column_width < 1000:
                     self.max_column_width += 10
                     # self.column_widths = get_column_widths(self.items, header=self.header, max_column_width=self.max_column_width, number_columns=self.number_columns, max_total_width=w)
-                    self.draw_screen(self.indexed_items, self.highlights)
+                    self.draw_screen()
             elif self.check_key("visual_selection_toggle", key, self.keys_dict):
                 self.logger.info(f"key_function visual_selection_toggle")
                 self.handle_visual_selection()
-                self.draw_screen(self.indexed_items, self.highlights)
+                self.draw_screen()
 
             elif self.check_key("visual_deselection_toggle", key, self.keys_dict):
                 self.logger.info(f"key_function visual_deselection_toggle")
                 self.handle_visual_selection(selecting=False)
-                self.draw_screen(self.indexed_items, self.highlights)
+                self.draw_screen()
 
             elif key == curses.KEY_RESIZE:  # Terminal resize signal
 
                 self.calculate_section_sizes()
-                self.column_widths = get_column_widths(self.items, header=self.header, max_column_width=self.max_column_width, number_columns=self.number_columns, max_total_width=self.rows_w, unicode_char_width=self.unicode_char_width)
-                self.draw_screen(self.indexed_items, self.highlights)
+                self.ensure_no_overscroll()
+
+                self.stdscr.clear()
+                self.stdscr.refresh()
+                self.draw_screen()
 
 
             elif self.check_key("filter_input", key, self.keys_dict):
                 self.logger.info(f"key_function filter_input")
-                self.draw_screen(self.indexed_items, self.highlights)
+                self.draw_screen()
                 usrtxt = f"{self.filter_query} " if self.filter_query else ""
-                field_end_f = lambda: self.stdscr.getmaxyx()[1]-38 if self.show_footer else lambda: self.stdscr.getmaxyx()[1]-3
-                if self.show_footer and self.footer.height >= 2: field_end_f = lambda: self.stdscr.getmaxyx()[1]-38
-                else: field_end_f = lambda: self.stdscr.getmaxyx()[1]-3
+                field_end_f = lambda: self.get_term_size()[1]-38 if self.show_footer else lambda: self.get_term_size()[1]-3
+                if self.show_footer and self.footer.height >= 2: field_end_f = lambda: self.get_term_size()[1]-38
+                else: field_end_f = lambda: self.get_term_size()[1]-3
                 self.set_registers()
                 words = self.get_word_list()
                 usrtxt, return_val = input_field(
@@ -3152,11 +3601,11 @@ class Picker:
                     usrtxt=usrtxt,
                     field_prefix=" Filter: ",
                     x=lambda:2,
-                    y=lambda: self.stdscr.getmaxyx()[0]-2,
+                    y=lambda: self.get_term_size()[0]-2,
                     # max_length=field_end,
                     max_length=field_end_f,
                     registers=self.registers,
-                    refresh_screen_function=lambda: self.draw_screen(self.indexed_items, self.highlights),
+                    refresh_screen_function=lambda: self.draw_screen(),
                     history=self.history_filter_and_search,
                     path_auto_complete=True,
                     formula_auto_complete=False,
@@ -3185,11 +3634,11 @@ class Picker:
 
             elif self.check_key("search_input", key, self.keys_dict):
                 self.logger.info(f"key_function search_input")
-                self.draw_screen(self.indexed_items, self.highlights)
+                self.draw_screen()
                 usrtxt = f"{self.search_query} " if self.search_query else ""
-                field_end_f = lambda: self.stdscr.getmaxyx()[1]-38 if self.show_footer else lambda: self.stdscr.getmaxyx()[1]-3
-                if self.show_footer and self.footer.height >= 3: field_end_f = lambda: self.stdscr.getmaxyx()[1]-38
-                else: field_end_f = lambda: self.stdscr.getmaxyx()[1]-3
+                field_end_f = lambda: self.get_term_size()[1]-38 if self.show_footer else lambda: self.get_term_size()[1]-3
+                if self.show_footer and self.footer.height >= 3: field_end_f = lambda: self.get_term_size()[1]-38
+                else: field_end_f = lambda: self.get_term_size()[1]-3
                 self.set_registers()
                 words = self.get_word_list()
                 usrtxt, return_val = input_field(
@@ -3197,10 +3646,10 @@ class Picker:
                     usrtxt=usrtxt,
                     field_prefix=" Search: ",
                     x=lambda:2,
-                    y=lambda: self.stdscr.getmaxyx()[0]-3,
+                    y=lambda: self.get_term_size()[0]-3,
                     max_length=field_end_f,
                     registers=self.registers,
-                    refresh_screen_function=lambda: self.draw_screen(self.indexed_items, self.highlights),
+                    refresh_screen_function=lambda: self.draw_screen(),
                     history=self.history_filter_and_search,
                     path_auto_complete=True,
                     formula_auto_complete=False,
@@ -3285,23 +3734,16 @@ class Picker:
                         sort_items(self.indexed_items, sort_method=self.columns_sort_method[self.sort_column], sort_column=self.sort_column, sort_reverse=self.sort_reverse[self.sort_column])  # Re-sort self.items based on new column
                 elif self.cancel_is_back:
                     function_data = self.get_function_data()
-                    function_data["last_key"] = key
                     return [], "escape", function_data
 
-
-                # else:
-                #     self.search_query = ""
-                #     self.mode_index = 0
-                #     self.highlights = [highlight for highlight in self.highlights if "type" not in highlight or highlight["type"] != "search" ]
-                #     continue
-                self.draw_screen(self.indexed_items, self.highlights)
+                self.draw_screen()
 
             elif self.check_key("opts_input", key, self.keys_dict):
                 self.logger.info(f"key_function opts_input")
                 usrtxt = f"{self.user_opts} " if self.user_opts else ""
-                field_end_f = lambda: self.stdscr.getmaxyx()[1]-38 if self.show_footer else lambda: self.stdscr.getmaxyx()[1]-3
-                if self.show_footer and self.footer.height >= 1: field_end_f = lambda: self.stdscr.getmaxyx()[1]-38
-                else: field_end_f = lambda: self.stdscr.getmaxyx()[1]-3
+                field_end_f = lambda: self.get_term_size()[1]-38 if self.show_footer else lambda: self.get_term_size()[1]-3
+                if self.show_footer and self.footer.height >= 1: field_end_f = lambda: self.get_term_size()[1]-38
+                else: field_end_f = lambda: self.get_term_size()[1]-3
                 self.set_registers()
                 words = self.get_word_list()
                 usrtxt, return_val = input_field(
@@ -3309,10 +3751,10 @@ class Picker:
                     usrtxt=usrtxt,
                     field_prefix=" Opts: ",
                     x=lambda:2,
-                    y=lambda: self.stdscr.getmaxyx()[0]-1,
+                    y=lambda: self.get_term_size()[0]-1,
                     max_length=field_end_f,
                     registers=self.registers,
-                    refresh_screen_function=lambda: self.draw_screen(self.indexed_items, self.highlights),
+                    refresh_screen_function=lambda: self.draw_screen(),
                     history=self.history_opts,
                     path_auto_complete=True,
                     formula_auto_complete=False,
@@ -3390,13 +3832,19 @@ class Picker:
             elif self.check_key("cycle_right_pane", key, self.keys_dict):
                 self.cycle_right_pane()
 
+            elif self.check_key("toggle_left_pane", key, self.keys_dict):
+                self.toggle_left_pane()
+
+            elif self.check_key("cycle_left_pane", key, self.keys_dict):
+                self.cycle_left_pane()
+
             elif self.check_key("pipe_input", key, self.keys_dict):
                 self.logger.info(f"key_function pipe_input")
                 # usrtxt = "xargs -d '\n' -I{}  "
                 usrtxt = "xargs "
-                field_end_f = lambda: self.stdscr.getmaxyx()[1]-38 if self.show_footer else lambda: self.stdscr.getmaxyx()[1]-3
-                if self.show_footer and self.footer.height >= 2: field_end_f = lambda: self.stdscr.getmaxyx()[1]-38
-                else: field_end_f = lambda: self.stdscr.getmaxyx()[1]-3
+                field_end_f = lambda: self.get_term_size()[1]-38 if self.show_footer else lambda: self.get_term_size()[1]-3
+                if self.show_footer and self.footer.height >= 2: field_end_f = lambda: self.get_term_size()[1]-38
+                else: field_end_f = lambda: self.get_term_size()[1]-3
                 self.set_registers()
                 
                 # Get list of available shell commands
@@ -3412,11 +3860,11 @@ class Picker:
                     usrtxt=usrtxt,
                     field_prefix=" Command: ",
                     x=lambda:2,
-                    y=lambda: self.stdscr.getmaxyx()[0]-2,
-                    literal=True,
+                    y=lambda: self.get_term_size()[0]-2,
+                    literal=False,
                     max_length=field_end_f,
                     registers=self.registers,
-                    refresh_screen_function=lambda: self.draw_screen(self.indexed_items, self.highlights),
+                    refresh_screen_function=lambda: self.draw_screen(),
                     history=self.history_pipes,
                     path_auto_complete=True,
                     formula_auto_complete=False,
@@ -3503,12 +3951,12 @@ class Picker:
 
             elif self.check_key("edit", key, self.keys_dict):
                 self.logger.info(f"key_function edit")
-                if len(self.indexed_items) > 0 and self.selected_column >=0 and self.editable_columns[self.selected_column]:
+                if len(self.indexed_items) > 0 and self.editable_columns[self.selected_column]:
                     current_val = self.indexed_items[self.cursor_pos][1][self.selected_column]
                     usrtxt = f"{current_val}"
-                    field_end_f = lambda: self.stdscr.getmaxyx()[1]-38 if self.show_footer else lambda: self.stdscr.getmaxyx()[1]-3
-                    if self.show_footer and self.footer.height >= 2: field_end_f = lambda: self.stdscr.getmaxyx()[1]-38
-                    else: field_end_f = lambda: self.stdscr.getmaxyx()[1]-3
+                    field_end_f = lambda: self.get_term_size()[1]-38 if self.show_footer else lambda: self.get_term_size()[1]-3
+                    if self.show_footer and self.footer.height >= 2: field_end_f = lambda: self.get_term_size()[1]-38
+                    else: field_end_f = lambda: self.get_term_size()[1]-3
                     self.set_registers()
                     words = self.get_word_list()
                     usrtxt, return_val = input_field(
@@ -3516,10 +3964,10 @@ class Picker:
                         usrtxt=usrtxt,
                         field_prefix=" Edit value: ",
                         x=lambda:2,
-                        y=lambda: self.stdscr.getmaxyx()[0]-2,
+                        y=lambda: self.get_term_size()[0]-2,
                         max_length=field_end_f,
                         registers=self.registers,
-                        refresh_screen_function=lambda: self.draw_screen(self.indexed_items, self.highlights),
+                        refresh_screen_function=lambda: self.draw_screen(),
                         history = self.history_edits,
                         path_auto_complete=True,
                         formula_auto_complete=True,
@@ -3532,15 +3980,56 @@ class Picker:
                             usrtxt = str(eval(usrtxt[3:]))
                         self.indexed_items[self.cursor_pos][1][self.selected_column] = usrtxt
                         self.history_edits.append(usrtxt)
+            elif self.check_key("edit_nvim", key, self.keys_dict):
+
+                def edit_strings_in_nvim(strings: list[str]) -> list[str]:
+                    """
+                    Opens a list of strings in nvim for editing and returns the modified strings.
+
+                    Args:
+                        strings (list[str]): The list of strings to edit.
+
+                    Returns:
+                        list[str]: The updated list of strings after editing in nvim.
+                    """
+
+                    # Open the strings in a tmpfile for editing
+                    with tempfile.NamedTemporaryFile(mode="w+", suffix=".txt", delete=False) as tmp:
+                        tmp.write("\n".join(strings))
+                        tmp.flush()
+                        tmp_name = tmp.name
+
+                    subprocess.run(["nvim", tmp_name])
+
+                    # Read the modified strings into a list and return them.
+                    with open(tmp_name, "r") as tmp:
+                        edited_content = tmp.read().splitlines()
+
+                    return edited_content
+
+                if len(self.indexed_items) > 0 and self.editable_columns[self.selected_column]:
+
+                    selected_cells = [self.items[index][self.selected_column] for index, selected in self.selections.items() if selected ]
+                    selected_cells_indices = [(index, self.selected_column) for index, selected in self.selections.items() if selected ]
+
+                    edited_cells = edit_strings_in_nvim(selected_cells)
+                    count = 0
+                    if len(edited_cells) == len(selected_cells_indices):
+                        for i, j in selected_cells_indices:
+                            self.items[i][j] = edited_cells[count]
+                            count += 1
+
+                    self.refresh_and_draw_screen()
+
 
             elif self.check_key("edit_picker", key, self.keys_dict):
                 self.logger.info(f"key_function edit_picker")
                 if len(self.indexed_items) > 0 and self.selected_column >=0 and self.editable_columns[self.selected_column]:
                     current_val = self.indexed_items[self.cursor_pos][1][self.selected_column]
                     usrtxt = f"{current_val}"
-                    field_end_f = lambda: self.stdscr.getmaxyx()[1]-38 if self.show_footer else lambda: self.stdscr.getmaxyx()[1]-3
-                    if self.show_footer and self.footer.height >= 2: field_end_f = lambda: self.stdscr.getmaxyx()[1]-38
-                    else: field_end_f = lambda: self.stdscr.getmaxyx()[1]-3
+                    field_end_f = lambda: self.get_term_size()[1]-38 if self.show_footer else lambda: self.get_term_size()[1]-3
+                    if self.show_footer and self.footer.height >= 2: field_end_f = lambda: self.get_term_size()[1]-38
+                    else: field_end_f = lambda: self.get_term_size()[1]-3
                     self.set_registers()
                     words = self.get_word_list()
                     usrtxt, return_val = input_field(
@@ -3548,10 +4037,10 @@ class Picker:
                         usrtxt=usrtxt,
                         field_prefix=" Edit value: ",
                         x=lambda:2,
-                        y=lambda: self.stdscr.getmaxyx()[0]-2,
+                        y=lambda: self.get_term_size()[0]-2,
                         max_length=field_end_f,
                         registers=self.registers,
-                        refresh_screen_function=lambda: self.draw_screen(self.indexed_items, self.highlights),
+                        refresh_screen_function=lambda: self.draw_screen(),
                         history = self.history_edits,
                         path_auto_complete=True,
                         formula_auto_complete=True,
@@ -3563,7 +4052,7 @@ class Picker:
                         self.indexed_items[self.cursor_pos][1][self.selected_column] = usrtxt
                         self.history_edits.append(usrtxt)
             elif self.check_key("edit_ipython", key, self.keys_dict):
-                self.logger.info(f"key_function edit_picker")
+                self.logger.info(f"key_function edit_ipython")
                 import IPython, termios
                 self.stdscr.clear()
                 restrict_curses(self.stdscr)
@@ -3600,11 +4089,11 @@ class Picker:
                 self.stdscr.clear()
                 self.stdscr.refresh()
                 self.initialise_variables()
-                self.draw_screen(self.indexed_items, self.highlights)
+                self.draw_screen()
 
 
 
-            self.draw_screen(self.indexed_items, self.highlights, clear=clear_screen)
+            self.draw_screen(clear=clear_screen)
 
 
 
@@ -3707,7 +4196,7 @@ def parse_arguments() -> Tuple[argparse.Namespace, dict]:
     #     input_arg = args.filename
 
     elif args.generate:
-        function_data["refresh_function"] = lambda : generate_picker_data(args.generate)
+        function_data["refresh_function"] = lambda items, header, visible_rows_indices, getting_data, state: generate_picker_data_from_file(args.generate, items, header, visible_rows_indices, getting_data, state)
         function_data["get_data_startup"] = True
         function_data["get_new_data"] = True
         return args, function_data
@@ -3806,14 +4295,6 @@ def unrestrict_curses(stdscr: curses.window) -> None:
 def main() -> None:
     """ Main function when listpick is executed. Deals with command line arguments and starts a Picker. """
     args, function_data = parse_arguments()
-
-    try:
-        if function_data["items"] == []:
-            function_data["items"] = test_items
-            function_data["highlights"] = test_highlights
-            function_data["header"] = test_header
-    except:
-        pass
         
     # function_data["colour_theme_number"] = 3
     function_data["highlights"]  = [
@@ -3959,7 +4440,7 @@ def main() -> None:
     # function_data["cell_cursor"] = True
     # function_data["display_modes"] = True
     # function_data["centre_in_cols"] = True
-    # function_data["show_row_header"] = True
+    function_data["show_row_header"] = True
     # function_data["keys_dict"] = picker_keys
     # function_data["id_column"] = -1
     # function_data["track_entries_upon_refresh"] = True
@@ -3975,10 +4456,23 @@ def main() -> None:
     # function_data["debug"] = True
     # function_data["debug_level"] = 1
 
+    # function_data["cell_cursor"] = False
+
     function_data["split_right"] = False
-    function_data["right_pane_index"] = 3
+    function_data["split_left"] = False
+    function_data["right_pane_index"] = 2
+    function_data["left_pane_index"] = 0
 
     function_data["right_panes"] = [
+        # Nopane
+        {
+            "proportion": 1/3,
+            "auto_refresh": False,
+            "get_data": lambda data, state: [],
+            "display": left_start_pane,
+            "data": ["Files", []],
+            "refresh_time": 1,
+        },
         # Graph or random numbers generated each second
         {
             "proportion": 1/2,
@@ -3990,22 +4484,31 @@ def main() -> None:
         },
         # list of numbers
         {
-            "proportion": 2/3,
+            "proportion": 1/3,
             "auto_refresh": False,
             "get_data": data_refresh_randint_title,
             "display": right_split_display_list,
             "data": ["Files", [str(x) for x in range(100)]],
             "refresh_time": 1.0,
         },
-        # File attribures
+        # File attributes
         {
-            "proportion": 2/3,
+            "proportion": 1/3,
             "auto_refresh": False,
             "get_data": lambda data, state: [],
             "display": right_split_file_attributes,
-            "data": ["Files", [str(x) for x in range(100)]],
+            "data": [],
             "refresh_time": 1.0,
         },
+        # File attributes dynamic
+        {
+            "proportion": 1/3,
+            "auto_refresh": True,
+            "get_data": update_file_attributes,
+            "display": right_split_file_attributes_dynamic,
+            "data": [],
+            "refresh_time": 2.0,
+        },
         # List of random numbers generated each second
         {
             "proportion": 1/2,
@@ -4025,7 +4528,79 @@ def main() -> None:
             "refresh_time": 1,
         },
     ]
-    function_data["require_option"] = [True for _ in function_data["items"]]
+    function_data["left_panes"] = [
+        # Nopane
+        {
+            "proportion": 1/3,
+            "auto_refresh": False,
+            "get_data": lambda data, state: [],
+            "display": left_start_pane,
+            "data": ["Files", []],
+            "refresh_time": 1,
+        },
+        # Graph or random numbers generated each second
+        {
+            "proportion": 1/2,
+            "auto_refresh": True,
+            "get_data": data_refresh_randint,
+            "display": left_split_graph,
+            "data": [],
+            "refresh_time": 1.0,
+        },
+        # list of numbers
+        {
+            "proportion": 1/3,
+            "auto_refresh": False,
+            "get_data": data_refresh_randint_title,
+            "display": left_split_display_list,
+            "data": ["Files", [str(x) for x in range(100)]],
+            "refresh_time": 1.0,
+        },
+        # File attributes
+        {
+            "proportion": 1/3,
+            "auto_refresh": False,
+            "get_data": lambda data, state: [],
+            "display": left_split_file_attributes,
+            "data": [],
+            "refresh_time": 1.0,
+        },
+        # File attributes dynamic
+        {
+            "proportion": 1/3,
+            "auto_refresh": True,
+            "get_data": update_file_attributes,
+            "display": left_split_file_attributes_dynamic,
+            "data": [],
+            "refresh_time": 2.0,
+        },
+        # List of random numbers generated each second
+        {
+            "proportion": 1/2,
+            "auto_refresh": True,
+            "get_data": data_refresh_randint_title,
+            "display": left_split_display_list,
+            "data": ["Files", []],
+            "refresh_time": 2,
+        },
+        # Nopane
+        {
+            "proportion": 1/3,
+            "auto_refresh": False,
+            "get_data": lambda data, state: [],
+            "display": lambda scr, x, y, w, h, state, row, cell, data: [],
+            "data": ["Files", []],
+            "refresh_time": 1,
+        },
+    ]
+    function_data["macros"] = [
+        # {
+        #     "keys": [ord('z')],
+        #     "description": "Display message via dbus.",
+        #     "function": lambda picker_obj: os.system("notify-send 'zkey pressed'")
+        # },
+    ]
+    # function_data["require_option"] = [True for _ in function_data["items"]]
 
     stdscr = start_curses()
     try: