listpick 0.1.16.8__py3-none-any.whl → 0.1.16.9__py3-none-any.whl

listpick/listpick_app.py

@@ -20,8 +20,10 @@ import json
 import threading
 import string
 import logging
+from copy import copy
 
 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 *
@@ -189,9 +191,17 @@ class Picker:
         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],
+
         # getting_data: threading.Event = threading.Event(),
 
     ):
+
+        self.screen_size_function = screen_size_function
         self.stdscr = stdscr
         self.items = items
         self.cursor_pos = cursor_pos
@@ -342,6 +352,11 @@ 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 = []
 
 
@@ -408,7 +423,10 @@ class Picker:
             return config
 
     def update_term_size(self):
-        self.term_h, self.term_w = self.stdscr.getmaxyx()
+        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):
         return self.stdscr.getmaxyx()
@@ -428,13 +446,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
         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
@@ -460,6 +500,14 @@ class Picker:
         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]]:
 
@@ -800,7 +848,8 @@ class Picker:
             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, clear: bool = True) -> None:
         """ Draw Picker screen. """
@@ -811,11 +860,11 @@ class Picker:
             self.stdscr.erase()
 
         self.update_term_size()
-        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 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
 
         # The height of the footer may need to be adjusted if the file changes.
         self.footer.adjust_sizes(self.term_h,self.term_w)
@@ -898,11 +947,13 @@ class Picker:
 
                 header_str += f"{col_str:^{self.column_widths[i]-len(number)}}"
                 header_str += self.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)
+            self.stdscr.addstr(header_ypos, self.rows_box_x_i, ' '*self.rows_w, curses.color_pair(self.colours_start+28) | curses.A_BOLD)
+            self.stdscr.addstr(header_ypos, self.startx, header_str, curses.color_pair(self.colours_start+4) | curses.A_BOLD)
 
             # Highlight sort column
             try:
@@ -918,17 +969,19 @@ class Picker:
                     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):
+                    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.startx:
+                        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:
-                            overflow = (len(up_to_selected_col)+len(highlighted_col_str)) - (self.leftmost_char+self.rows_w - self.startx)
+                            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
@@ -939,14 +992,18 @@ class Picker:
                         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)
 
-                        x_pos = self.startx
                         self.stdscr.addstr(header_ypos, x_pos , disp_str, colour)
                     # The cell is to the left of the screen
                     else:
@@ -982,17 +1039,18 @@ class Picker:
             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
@@ -1000,7 +1058,8 @@ class Picker:
                 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:
+                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
@@ -1011,15 +1070,22 @@ class Picker:
                     # 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)
+                    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):
+                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
                     # 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]
+                    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
@@ -1098,6 +1164,7 @@ class Picker:
         l0_highlights, l1_highlights, l2_highlights = sort_highlights(self.highlights)
 
 
+        row_width = sum(self.column_widths) + len(self.separator)*(len(self.column_widths)-1)
         for idx in range(start_index, end_index):
             item = self.indexed_items[idx]
             y = idx - start_index + self.top_space
@@ -1109,18 +1176,21 @@ 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 = 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
@@ -1157,7 +1227,7 @@ class Picker:
             # 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:
@@ -1191,7 +1261,7 @@ class Picker:
                 if self.cell_cursor:
                     highlight_cell(idx, self.selected_column, 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)
@@ -1211,7 +1281,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:
@@ -1240,20 +1311,46 @@ 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,
+            )
+        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 [],
@@ -1261,7 +1358,6 @@ class Picker:
                 data=data,
             )
 
-        self.stdscr.refresh()
         ## Display infobox
         if self.display_infobox:
             self.infobox(self.stdscr, message=self.infobox_items, title=self.infobox_title)
@@ -1309,6 +1405,7 @@ class Picker:
                 "reset_colours": False,
                 "cell_cursor": False,
                 "split_right": False,
+                "split_left": False,
                 "crosshair_cursor": False,
             }
 
@@ -1427,6 +1524,9 @@ class Picker:
             "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,
 
         }
@@ -1464,6 +1564,9 @@ class Picker:
             "centre_in_cols",
             "centre_in_terminal",
             "split_right",
+            "left_pane_index",
+            "split_left",
+            "left_pane_index",
         ]
 
         for var in variables:
@@ -1557,6 +1660,7 @@ class Picker:
             "number_columns": False,
             "reset_colours": False,
             "split_right": False,
+            "split_left": False,
             "cell_cursor": False,
             "crosshair_cursor": False,
         }
@@ -1569,6 +1673,7 @@ class Picker:
 
             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()
 
@@ -1617,9 +1722,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)
@@ -1757,14 +1864,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:
@@ -2389,11 +2506,22 @@ class Picker:
             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())
 
+    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())
+
 
     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"]
+
+    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"]
 
     def run(self) -> Tuple[list[int], str, dict]:
         """ Run the picker. """
@@ -2411,7 +2539,8 @@ class Picker:
 
         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)
@@ -2446,11 +2575,7 @@ class Picker:
         tty_fd, self.saved_terminal_state = open_tty()
 
         self.update_term_size()
-        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.calculate_section_sizes()
 
         def terminal_resized(old_w, old_h) -> bool:
             w, h = os.get_terminal_size()
@@ -2486,14 +2611,6 @@ class Picker:
             if self.term_resize_event: 
                 key = curses.KEY_RESIZE
 
-            self.update_term_size()
-
-            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
 
@@ -2545,11 +2662,17 @@ class Picker:
                 self.initial_time_footer = time.time()
                 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")
@@ -3006,7 +3129,7 @@ class Picker:
                 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
+                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
@@ -3033,7 +3156,7 @@ class Picker:
                 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
+                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:
@@ -3048,9 +3171,9 @@ class Picker:
                 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:
+                    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)
+                    self.leftmost_char = min(self.leftmost_char, row_width - (self.rows_w) + self.left_gutter_width+5)
                 if sum(self.column_widths) + len(self.column_widths)*len(self.separator) < self.rows_w:
                     self.leftmost_char = 0
 
@@ -3058,9 +3181,9 @@ class Picker:
                 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:
+                    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)
+                    self.leftmost_char = min(self.leftmost_char, row_width - (self.rows_w) + self.left_gutter_width+5)
                 if sum(self.column_widths) + len(self.column_widths)*len(self.separator) < self.rows_w:
                     self.leftmost_char = 0
 
@@ -3091,7 +3214,16 @@ class Picker:
                 #     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.indexed_items):
+                    row_width = sum(self.column_widths) + len(self.separator)*(len(self.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.column_widths) + (len(self.column_widths)-1)*len(self.separator)
+                # self.leftmost_char = max(0, longest_row_str_len-self.rows_w+2+5)
+
+
+
                 if len(self.items):
                     self.selected_column = len(self.items[0])-1
 
@@ -3186,6 +3318,13 @@ class Picker:
 
                 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)
+
+                row_width = sum(self.column_widths) + len(self.separator)*(len(self.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
                 self.stdscr.clear()
                 self.stdscr.refresh()
                 self.draw_screen()
@@ -3442,6 +3581,12 @@ 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{}  "
@@ -4003,7 +4148,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
@@ -4019,10 +4164,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["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,
@@ -4034,7 +4192,7 @@ 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,
@@ -4043,7 +4201,7 @@ def main() -> None:
         },
         # File attributes
         {
-            "proportion": 2/3,
+            "proportion": 1/3,
             "auto_refresh": False,
             "get_data": lambda data, state: [],
             "display": right_split_file_attributes,
@@ -4052,7 +4210,7 @@ def main() -> None:
         },
         # File attributes dynamic
         {
-            "proportion": 2/3,
+            "proportion": 1/3,
             "auto_refresh": True,
             "get_data": update_file_attributes,
             "display": right_split_file_attributes_dynamic,
@@ -4078,7 +4236,72 @@ 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["require_option"] = [True for _ in function_data["items"]]
 
     stdscr = start_curses()
     try:

listpick/pane/left_pane_functions.py

@@ -0,0 +1,198 @@
+#!/bin/python
+# -*- coding: utf-8 -*-
+"""
+pane_functions.py
+Functions which are run by a listpick Picker to display data in a pane.
+
+Author: GrimAndGreedy
+License: MIT
+"""
+
+import curses
+import os
+from listpick.pane.pane_utils import get_file_attributes, get_graph_string, escape_ansi
+from listpick.pane.get_data import update_file_attributes
+
+def left_start_pane(stdscr, x, y, w, h, state, row, cell, data: list = [], test: bool = False):
+    """
+    Display file attributes in right pane.
+    """
+    if test: return True
+
+    # Title
+    for i in range(h):
+        s = '*'*w
+        stdscr.addstr(y+i, x, s)
+
+
+    stdscr.addstr(y, x, "+")
+    stdscr.addstr(y+h-1, x, "+")
+    stdscr.addstr(y, x+w-1, "+")
+    stdscr.addstr(y+h-1, x+w-1, "+")
+
+
+    stdscr.addstr(y+1, x, f"{w},{h}")
+
+    return []
+
+
+def left_split_file_attributes(stdscr, x, y, w, h, state, row, cell, data: list = [], test: bool = False):
+    """
+    Display file attributes in right pane.
+    """
+    if test: return True
+
+    # Title
+    title = "File attributes"
+    if len(title) < w: title = f"{title:^{w}}"
+    stdscr.addstr(y, x,title[:w], curses.color_pair(state["colours_start"]+4) | curses.A_BOLD)
+
+    # Separator
+    for j in range(h):
+        stdscr.addstr(j+y, x+w-1, ' ', curses.color_pair(state["colours_start"]+16))
+
+    # Display pane count
+    pane_count = len(state["right_panes"])
+    pane_index = state["right_pane_index"]
+    if pane_count > 1:
+        s = f" {pane_index+1}/{pane_count} "
+        stdscr.addstr(y+h-1, x, s, curses.color_pair(state["colours_start"]+20))
+
+    # Filename/cursor cell value
+    stdscr.addstr(y+2, x+2, cell[:w-3])
+
+    attributes = get_file_attributes(cell)
+    for i, attr in enumerate(attributes):
+        stdscr.addstr(y+3+i, x+4, attr[:w-5])
+
+    return []
+
+
+def left_split_file_attributes_dynamic(stdscr, x, y, w, h, state, row, cell, data: list = [], test: bool = False):
+    """
+    Display file attributes in right pane.
+    """
+    if test: return True
+
+    # Title
+    title = "File attributes"
+    if len(title) < w: title = f"{title:^{w}}"
+    stdscr.addstr(y, x,title[:w], curses.color_pair(state["colours_start"]+4) | curses.A_BOLD)
+
+    # Separator
+    for j in range(h):
+        stdscr.addstr(j+y, x+w-1, ' ', curses.color_pair(state["colours_start"]+16))
+
+    # Display pane count
+    pane_count = len(state["right_panes"])
+    pane_index = state["right_pane_index"]
+    if pane_count > 1:
+        s = f" {pane_index+1}/{pane_count} "
+        stdscr.addstr(y+h-1, x, s, curses.color_pair(state["colours_start"]+20))
+
+    if len(state["indexed_items"]) == 0:
+        return []
+
+    # Filename/cursor cell value
+    stdscr.addstr(y+2, x+2, cell[:w-3])
+
+    # If the cursor-hovered file is different then reload the data
+    if data[1] != cell:
+        data[:] = update_file_attributes(data, state)
+
+    # attributes = get_file_attributes(cell)
+    if len(data)  == 0: return []
+    attributes = data[0]
+    for i, attr in enumerate(attributes):
+        stdscr.addstr(y+3+i, x+4, attr[:w-5])
+
+    return []
+
+def left_split_graph(stdscr, x, y, w, h, state, row, cell, data: list = [], test: bool = False):
+    """
+    Display a graph of the data in right pane.
+
+    data[0] = x_vals
+    data[1] = y_vals
+    data[2] = id
+    """
+    if test: return True
+
+    # Title
+    title = "Graph"
+    if len(title) < w: title = f"{title:^{w}}"
+    stdscr.addstr(y, x,title[:w], curses.color_pair(state["colours_start"]+4) | curses.A_BOLD)
+
+    # Separator
+    for j in range(h):
+        stdscr.addstr(j+y, x+w-1, ' ', curses.color_pair(state["colours_start"]+16))
+
+
+    # Display pane count
+    pane_count = len(state["right_panes"])
+    pane_index = state["right_pane_index"]
+    if pane_count > 1:
+        s = f" {pane_index+1}/{pane_count} "
+        stdscr.addstr(y+h-1, x, s, curses.color_pair(state["colours_start"]+20))
+
+    try:
+        import plotille as plt
+    except:
+        s = f"No module named 'plotille'"
+        stdscr.addstr(y+2, x+1, s[:w-2])
+        return None
+
+
+
+    # x_vals, y_vals = list(range(100)), [x**2 for x in range(100)]
+    if data in [[], {}, None]:
+        return None
+    x_vals, y_vals = data[0], data[1]
+    graph_str = get_graph_string(x_vals, y_vals, width=w-3-10, height=h-3)
+    for i, s in enumerate(graph_str.split("\n")):
+        s = escape_ansi(s)
+        stdscr.addstr(y+2+i, x+1, s[:w-2])
+
+    return []
+
+
+
+
+def left_split_display_list(stdscr, x, y, w, h, state, row, cell, data: list = [], test: bool = False):
+    """
+    data[0]:str = title
+    data[1]:list[str] = list of strings to display
+    """
+    if test: return True
+
+    # Title
+    title = data[0]
+    if len(title) < w: title = f"{title:^{w}}"
+    stdscr.addstr(y, x,title[:w], curses.color_pair(state["colours_start"]+4) | curses.A_BOLD)
+
+    # Separator
+    for j in range(h):
+        stdscr.addstr(j+y, x+w-1, ' ', curses.color_pair(state["colours_start"]+16))
+
+
+    # Display pane count
+    pane_count = len(state["right_panes"])
+    pane_index = state["right_pane_index"]
+    if pane_count > 1:
+        s = f" {pane_index+1}/{pane_count} "
+        stdscr.addstr(y+h-1, x, s, curses.color_pair(state["colours_start"]+20))
+
+    if data in [[], {}, None]:
+        return None
+
+    items = data[1]
+    number_to_display = min(len(items), h-3)
+    for i in range(number_to_display):
+        s = items[i]
+        stdscr.addstr(y+1+i, x+2, s[:w-2])
+
+    if number_to_display < len(items):
+        stdscr.addstr(y+1+number_to_display, x+2, f" ... {len(items)-number_to_display} more"[:w-2])
+
+
+    return []

listpick/pane/pane_functions_1.py

@@ -0,0 +1,175 @@
+#!/bin/python
+# -*- coding: utf-8 -*-
+"""
+pane_functions.py
+Functions which are run by a listpick Picker to display data in a pane.
+
+Author: GrimAndGreedy
+License: MIT
+"""
+
+import curses
+import os
+from listpick.pane.pane_utils import get_file_attributes, get_graph_string, escape_ansi
+from listpick.pane.get_data import update_file_attributes
+
+def right_split_file_attributes(stdscr, x, y, w, h, state, row, cell, data: list = [], test: bool = False):
+    """
+    Display file attributes in right pane.
+    """
+    if test: return True
+
+    # Title
+    title = "File attributes"
+    if len(title) < w: title = f"{title:^{w}}"
+    stdscr.addstr(y, x,title[:w], curses.color_pair(state["colours_start"]+4) | curses.A_BOLD)
+
+    # Separator
+    for j in range(h):
+        stdscr.addstr(j+y, x, ' ', curses.color_pair(state["colours_start"]+16))
+
+    # Display pane count
+    pane_count = len(state["right_panes"])
+    pane_index = state["right_pane_index"]
+    if pane_count > 1:
+        s = f" {pane_index+1}/{pane_count} "
+        stdscr.addstr(y+h-1, x+w-len(s)-1, s, curses.color_pair(state["colours_start"]+20))
+
+    # Filename/cursor cell value
+    stdscr.addstr(y+2, x+2, cell[:w-3])
+
+    attributes = get_file_attributes(cell)
+    for i, attr in enumerate(attributes):
+        stdscr.addstr(y+3+i, x+4, attr[:w-5])
+
+    return []
+
+
+def right_split_file_attributes_dynamic(stdscr, x, y, w, h, state, row, cell, data: list = [], test: bool = False):
+    """
+    Display file attributes in right pane.
+    """
+    if test: return True
+
+    # Title
+    title = "File attributes"
+    if len(title) < w: title = f"{title:^{w}}"
+    stdscr.addstr(y, x,title[:w], curses.color_pair(state["colours_start"]+4) | curses.A_BOLD)
+
+    # Separator
+    for j in range(h):
+        stdscr.addstr(j+y, x, ' ', curses.color_pair(state["colours_start"]+16))
+
+    # Display pane count
+    pane_count = len(state["right_panes"])
+    pane_index = state["right_pane_index"]
+    if pane_count > 1:
+        s = f" {pane_index+1}/{pane_count} "
+        stdscr.addstr(y+h-1, x+w-len(s)-1, s, curses.color_pair(state["colours_start"]+20))
+
+    if len(state["indexed_items"]) == 0:
+        return []
+
+    # Filename/cursor cell value
+    stdscr.addstr(y+2, x+2, cell[:w-3])
+
+    # If the cursor-hovered file is different then reload the data
+    if data[1] != cell:
+        data[:] = update_file_attributes(data, state)
+
+    # attributes = get_file_attributes(cell)
+    if len(data)  == 0: return []
+    attributes = data[0]
+    for i, attr in enumerate(attributes):
+        stdscr.addstr(y+3+i, x+4, attr[:w-5])
+
+    return []
+
+def right_split_graph(stdscr, x, y, w, h, state, row, cell, data: list = [], test: bool = False):
+    """
+    Display a graph of the data in right pane.
+
+    data[0] = x_vals
+    data[1] = y_vals
+    data[2] = id
+    """
+    if test: return True
+
+    # Title
+    title = "Graph"
+    if len(title) < w: title = f"{title:^{w}}"
+    stdscr.addstr(y, x,title[:w], curses.color_pair(state["colours_start"]+4) | curses.A_BOLD)
+
+    # Separator
+    for j in range(h):
+        stdscr.addstr(j+y, x, ' ', curses.color_pair(state["colours_start"]+16))
+
+
+    # Display pane count
+    pane_count = len(state["right_panes"])
+    pane_index = state["right_pane_index"]
+    if pane_count > 1:
+        s = f" {pane_index+1}/{pane_count} "
+        stdscr.addstr(y+h-1, x+w-len(s)-1, s, curses.color_pair(state["colours_start"]+20))
+
+    try:
+        import plotille as plt
+    except:
+        s = f"No module named 'plotille'"
+        stdscr.addstr(y+2, x+2, s[:w-2])
+        return None
+
+
+
+    # x_vals, y_vals = list(range(100)), [x**2 for x in range(100)]
+    if data in [[], {}, None]:
+        return None
+    x_vals, y_vals = data[0], data[1]
+    graph_str = get_graph_string(x_vals, y_vals, width=w-3-10, height=h-3)
+    for i, s in enumerate(graph_str.split("\n")):
+        s = escape_ansi(s)
+        stdscr.addstr(y+2+i, x+2, s[:w-2])
+
+    return []
+
+
+
+
+def right_split_display_list(stdscr, x, y, w, h, state, row, cell, data: list = [], test: bool = False):
+    """
+    data[0]:str = title
+    data[1]:list[str] = list of strings to display
+    """
+    if test: return True
+
+    # Title
+    title = data[0]
+    if len(title) < w: title = f"{title:^{w}}"
+    stdscr.addstr(y, x,title[:w], curses.color_pair(state["colours_start"]+4) | curses.A_BOLD)
+
+    # Separator
+    for j in range(h):
+        stdscr.addstr(j+y, x, ' ', curses.color_pair(state["colours_start"]+16))
+
+
+    # Display pane count
+    pane_count = len(state["right_panes"])
+    pane_index = state["right_pane_index"]
+    if pane_count > 1:
+        s = f" {pane_index+1}/{pane_count} "
+        stdscr.addstr(y+h-1, x+w-len(s)-1, s, curses.color_pair(state["colours_start"]+20))
+
+    if data in [[], {}, None]:
+        return None
+
+    items = data[1]
+    number_to_display = min(len(items), h-3)
+    for i in range(number_to_display):
+        s = items[i]
+        stdscr.addstr(y+1+i, x+2, s[:w-2])
+
+    if number_to_display < len(items):
+        stdscr.addstr(y+1+number_to_display, x+2, f" ... {len(items)-number_to_display} more"[:w-2])
+
+
+    return []

listpick/ui/build_help.py

@@ -145,12 +145,14 @@ def build_help_rows(keys_dict: dict, debug: bool = False) -> list[list[str]]:
         "sheet_next":                       "Go to the next sheet.",
         "sheet_prev":                       "Go to the previous sheet.",
         "toggle_right_pane":                "Toggle the right pane",
-        "cycle_right_pane":                 "Cycle through right panes",
+        "cycle_right_pane":                 "Cycle through right pane views",
+        "toggle_left_pane":                "Toggle the left pane",
+        "cycle_left_pane":                 "Cycle through left pane views",
     }
     sections = {
         "Navigation:": [ "cursor_down", "cursor_up", "half_page_up", "half_page_down", "page_up", "page_down", "cursor_bottom", "cursor_top", "five_up", "five_down", "scroll_right", "scroll_left", "scroll_right_25", "scroll_left_25", "scroll_far_right", "scroll_far_left" ],
         "Selection:": [ "toggle_select", "select_all", "select_none", "visual_selection_toggle", "visual_deselection_toggle", "enter" ],
-        "UI:": [ "toggle_footer", "redraw_screen", "decrease_lines_per_page", "increase_lines_per_page", "increase_column_width", "decrease_column_width", "notification_toggle", "toggle_right_pane", "cycle_right_pane"],
+        "UI:": [ "toggle_footer", "redraw_screen", "decrease_lines_per_page", "increase_lines_per_page", "increase_column_width", "decrease_column_width", "notification_toggle", "toggle_right_pane", "cycle_right_pane", "toggle_left_pane", "cycle_left_pane"],
         "Sort:": [ "cycle_sort_method", "cycle_sort_method_reverse", "cycle_sort_order", ] ,
         "Data manipulation:": [ "delete", "delete_column", "edit", "edit_picker", "edit_ipython", "add_column_before", "add_column_after", "add_row_before", "add_row_after"],
         "Filter and search:": [ "filter_input", "search_input", "continue_search_forward", "continue_search_backward", ] ,

listpick/ui/keys.py

@@ -51,7 +51,7 @@ picker_keys = {
     "continue_search_forward":          [ord('n')],
     "continue_search_backward":         [ord('N')],
     "cancel":                           [27], # Escape key
-    "opts_input":                       [ord(':')],
+    "opts_input":                       [ord('e')],
     "opts_select":                      [ord('o')],
     "mode_next":                        [9], # Tab key
     "mode_prev":                        [353], # Shift+Tab key
@@ -90,6 +90,8 @@ picker_keys = {
     # "sheet_prev":                           [],
     "toggle_right_pane":                             [ord("'")], 
     "cycle_right_pane":                             [ord('"')], 
+    "toggle_left_pane":                             [ord(";")], 
+    "cycle_left_pane":                             [ord(':')], 
 }
 
 

{listpick-0.1.16.8.dist-info → listpick-0.1.16.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: listpick
-Version: 0.1.16.8
+Version: 0.1.16.9
 Summary: Listpick is a powerful TUI data tool for creating TUI apps or viewing/comparing tabulated data.
 Home-page: https://github.com/grimandgreedy/listpick
 Author: Grim
@@ -41,7 +41,7 @@ Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary
 
-# listpick
+qq# listpick
 
 listpick is a TUI tool which displays a tabulated list of rows and allows the user to operate upon these rows--select, copy, pipe. A very simple concept but also, I hope, a powerful tool that will make it easier for people to develop TUI apps.
 
@@ -102,31 +102,32 @@ The application allows you to:
 ## Examples
 
 
-### Identify video duplicates (./examples/data_generation//video_duplicates.toml):
-```python 
-listpick -g ./examples/data_generation/video_duplicates.toml
-```
-  - From the list of commands in the toml file we generate the properties we will use to identify the duplicates. 
 
-  - In the example file we set the directory and get the files with a simle `eza` (`ls`) command. We could also use `find` or `cat` from a list of files.
+### Aria2TUI
 
+[Aria2TUI](https://github.com/grimandgreedy/Aria2TUI) is implemented using listpick. This is a good example of how listpick can be used for menus, data viewing, and active data retrieval.
 
-  - We get the SHA1 hash to identify identical files; we also get the size, duration, resolution, and bitrate so that we can identify a video duplicate that may have the same duration but a lower resolution.
+<div align="center"> <img src="assets/aria2tui_graph_screenshot.png" alt="Aria2TUI" width="70%"> </div>
 
-<div align="center"> <img src="assets/file_compare.png" alt="Video Compare" width="70%"> </div>
+### lpfman
+[lpfman](https://github.com/grimandgreedy/lpfman) is a terminal file manager with extensive column support.
 
+<div align="center"> <img src="https://github.com/grimandgreedy/lpfman/blob/master/assets/lpfman_image_preview.png?raw=true" alt="lpfman" width="70%"> </div>
 
-### Aria2TUI
 
-[Aria2TUI](https://github.com/grimandgreedy/Aria2TUI) is implemented using listpick. This is a good example of how listpick can be used for menus, data viewing, and active data retrieval.
+### Data generation from toml file
+
+```python 
+listpick -g ./examples/data_generation/video_duplicates.toml
+```
+  - From the list of commands in the toml file we generate the properties we will use to identify the duplicates. 
 
-<div align="center"> <img src="assets/aria2tui_screenshot.png" alt="Aria2TUI" width="70%"> </div>
+  - In the example file we set the directory and get the files with a simle `eza` (`ls`) command. We could also use `find` or `cat` from a list of files.
 
-### lpfman
-[lpfman](https://github.com/grimandgreedy/lpfman) is a basic file manager created for the purposes of illustrating how easy TUI apps can be developed with the use of listpick. In 20 minutes and <100 lines of code we made a very basic file manager.
 
-<div align="center"> <img src="assets/lpfman.png" alt="lpfman" width="70%"> </div>
+  - We get the SHA1 hash to identify identical files; we also get the size, duration, resolution, and bitrate so that we can identify a video duplicate that may have the same duration but a lower resolution.
 
+<div align="center"> <img src="assets/file_compare.png" alt="Video Compare" width="70%"> </div>
 
 
 ## Description

{listpick-0.1.16.8.dist-info → listpick-0.1.16.9.dist-info}/RECORD

@@ -1,17 +1,19 @@
 listpick/__init__.py,sha256=ExXc97-bibodH--wlwpQivl0zCNR5D1hvpvrf7OBofU,154
 listpick/__main__.py,sha256=wkCjDdqw093W27yWwnlC3nG_sMRKaIad7hHHWy0RBgY,193
-listpick/listpick_app.py,sha256=oFkMaWdoqd6fId1hBSavY2Nsoql6EcVppd4d7mgVVGo,201956
+listpick/listpick_app.py,sha256=t690QmA4_fJ-zi2PhmRrwjMUr2oKOvxEScdDner2mr0,212136
 listpick/pane/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 listpick/pane/get_data.py,sha256=l12mHIb6qoZWIfW5zZZY8K8EqNcyIcRiHgtRaM2CVGs,2735
+listpick/pane/left_pane_functions.py,sha256=SVIW4Ef8uNPBQRk4hL67mEFL3pfgChSFZSMRz06CVzw,5543
 listpick/pane/pane_functions.py,sha256=_dL9jHpd3sT0enL9H_bMcUsBlMELXdtP9dtKFSC2KPQ,5117
+listpick/pane/pane_functions_1.py,sha256=_dL9jHpd3sT0enL9H_bMcUsBlMELXdtP9dtKFSC2KPQ,5117
 listpick/pane/pane_utils.py,sha256=cnuzBH52wdWoKrHR6iMBF4N-uhwpXYpHDnrglk21pqg,2539
 listpick/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-listpick/ui/build_help.py,sha256=FNKshZpYJfgF-17ad5Mq0IGeBEo7y52u3CcpQ8ajlOs,10774
+listpick/ui/build_help.py,sha256=DJm_WxgdfrI6nJ8yjdraBrI6bECvNrXp1vU-kHxCczo,10961
 listpick/ui/draw_screen.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 listpick/ui/footer.py,sha256=NcdH1uO_ma91m0qCczyQZ3zGrexfkiEnwDf5E4tHSMk,15089
 listpick/ui/help_screen.py,sha256=zbfGIgb-IXtATpl4_Sx7nPbsnRXZ7eiMYlCKGS9EFmw,5608
 listpick/ui/input_field.py,sha256=scJjvmSS0QqeDbCky7_0Zgt35Aki7gezRJkrQROlLg4,30034
-listpick/ui/keys.py,sha256=rOOhvxfrQ1LRuLJYf_6pAQcuugxHo-M9TQn7Qow5uIg,13716
+listpick/ui/keys.py,sha256=FlpdWqX1lTP7K6gqHn9jfH2MmuloigeOA7EMzYhaJV8,13845
 listpick/ui/picker_colours.py,sha256=FFsyny_q0mGO6u7B1n7anuReBtP7Jw6LrgX5ycN-MRM,13413
 listpick/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 listpick/utils/clipboard_operations.py,sha256=ORdNm2kgGbfs51xJSvgJPERgoSmBgT11axuMkvSoP9A,3133
@@ -31,9 +33,9 @@ listpick/utils/sorting.py,sha256=WZZiVlVA3Zkcpwji3U5SNFlQ14zVEk3cZJtQirBkecQ,532
 listpick/utils/table_to_list_of_lists.py,sha256=XBj7eGBDF15BRME-swnoXyOfZWxXCxrXp0pzsBfcJ5g,12224
 listpick/utils/user_input.py,sha256=L3ylI7nnuFM_TP1XKwpiKpxUSkNb2W5cr7mJjTmv_6E,4582
 listpick/utils/utils.py,sha256=nsR6orCBQy3rTXrCweq8cV-RzRVU15v3J9NclPeAOJk,13741
-listpick-0.1.16.8.dist-info/licenses/LICENSE.txt,sha256=2mP-MRHJptADDNE9VInMNg1tE-C6Qv93Z4CCQKrpg9w,1061
-listpick-0.1.16.8.dist-info/METADATA,sha256=ywGEK-Ljulg5NRWTW-AKhbZSCDOcASjOK5UdOSmWeo4,8128
-listpick-0.1.16.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-listpick-0.1.16.8.dist-info/entry_points.txt,sha256=-QCf_BKIkUz35Y9nkYpjZWs2Qg0KfRna2PAs5DnF6BE,43
-listpick-0.1.16.8.dist-info/top_level.txt,sha256=5mtsGEz86rz3qQDe0D463gGjAfSp6A3EWg4J4AGYr-Q,9
-listpick-0.1.16.8.dist-info/RECORD,,
+listpick-0.1.16.9.dist-info/licenses/LICENSE.txt,sha256=2mP-MRHJptADDNE9VInMNg1tE-C6Qv93Z4CCQKrpg9w,1061
+listpick-0.1.16.9.dist-info/METADATA,sha256=S_kppW9DHyjThJf01PtkuKOA2EAQQVh3J31Oe8iE_Hc,8024
+listpick-0.1.16.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+listpick-0.1.16.9.dist-info/entry_points.txt,sha256=-QCf_BKIkUz35Y9nkYpjZWs2Qg0KfRna2PAs5DnF6BE,43
+listpick-0.1.16.9.dist-info/top_level.txt,sha256=5mtsGEz86rz3qQDe0D463gGjAfSp6A3EWg4J4AGYr-Q,9
+listpick-0.1.16.9.dist-info/RECORD,,