listpick 0.1.15.6__py3-none-any.whl → 0.1.15.8__py3-none-any.whl

listpick/listpick_app.py

@@ -23,6 +23,7 @@ import logging
 import tty
 import select
 
+from listpick.pane.pane_utils import get_file_attributes
 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 *
@@ -191,16 +192,8 @@ class Picker:
         sheet_states: list = [{}],
 
         split_right: bool = False,
-        split_right_proportion: float = 1/2,
-        split_right_function: Callable = lambda stdscr, x, y, w, h, state, row, cell, data, test: False,
-        split_right_auto_refresh: bool = False,
-        split_right_refresh_data: Callable = lambda old_data, arg_dict: [],
-        split_right_refresh_data_timer: float = 1.0,
-        split_right_data: list = [],
-        
-
-
-
+        right_panes: list = [],
+        right_pane_index: int = 0,
     ):
         self.stdscr = stdscr
         self.items = items
@@ -350,13 +343,8 @@ class Picker:
         self.sheets = sheets
 
         self.split_right = split_right
-        self.split_right_proportion = split_right_proportion
-        self.split_right_function = split_right_function
-        self.split_right_auto_refresh = split_right_auto_refresh
-        self.split_right_refresh_data = split_right_refresh_data
-        self.split_right_refresh_data_timer = split_right_refresh_data_timer
-        self.split_right_data = split_right_data
-
+        self.right_panes = right_panes
+        self.right_pane_index = right_pane_index
         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
@@ -426,8 +414,9 @@ class Picker:
         ## self.top_space
         h, w = self.stdscr.getmaxyx()
         self.term_h, self.term_w = self.stdscr.getmaxyx()
-        if self.split_right and self.split_right_function(self.stdscr, 0,0,0,0,{},[],[],"",test=True):
-            self.rows_w, self.rows_h = int(self.term_w*self.split_right_proportion), 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
 
@@ -787,8 +776,9 @@ class Picker:
 
         h, w = self.stdscr.getmaxyx()
         self.term_h, self.term_w = self.stdscr.getmaxyx()
-        if self.split_right and self.split_right_function(self.stdscr, 0,0,0,0,{},[],[],"",test=True):
-            self.rows_w, self.rows_h = int(self.term_w*self.split_right_proportion), 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
 
@@ -881,15 +871,69 @@ class Picker:
             # Highlight sort column
             try:
                 if self.selected_column != None and self.selected_column not in self.hidden_columns:
-                    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)
-                        highlighted_col_str = (number+f"{self.header[self.selected_column]:^{self.column_widths[self.selected_column]-len(number)}}") + 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)
-                        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)
+                    # 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
+
+                    # 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, curses.color_pair(self.colours_start+19) | curses.A_BOLD)
+                    # 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, curses.color_pair(self.colours_start+19) | curses.A_BOLD)
+                    # 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, curses.color_pair(self.colours_start+19) | curses.A_BOLD)
+                    # The cell is to the left of the screen
+                    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
                 
@@ -902,11 +946,14 @@ class Picker:
                 else:
                     self.stdscr.addstr(y, 0, 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):
+
+        def highlight_cell(row: int, col:int, visible_column_widths, colour_pair_number: int = 5, y:int = 0):
+            
             cell_pos = sum(visible_column_widths[:col])+col*len(self.separator)-self.leftmost_char + self.startx
             # 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
+
             try:
                 # Start of cell is on screen
                 if self.startx <= cell_pos <= self.rows_w:
@@ -916,17 +963,23 @@ class Picker:
                     else:
                         cell_value = self.indexed_items[row][1][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)-len(self.separator), self.centre_in_cols, self.unicode_char_width)
-                    cell_value = cell_value + 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, curses.color_pair(self.colours_start+colour_pair_number) | curses.A_BOLD)
                 # Part of the cell is on screen
-                elif self.startx <= cell_pos+cell_width <= self.rows_w:
+                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_start:visible_column_widths[col]]
+                    # 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, curses.color_pair(self.colours_start+colour_pair_number) | curses.A_BOLD)
+                else:
+                    pass
+                # if colour_pair_number == 5:
             except:
                 pass
 
@@ -1009,7 +1062,17 @@ class Picker:
             # row_str = truncate_to_display_width(row_str, min(w-self.startx, visible_columns_total_width))
             row_str_orig = format_row(item[1], self.hidden_columns, self.column_widths, self.separator, self.centre_in_cols, self.unicode_char_width)
             row_str_left_adj = clip_left(row_str_orig, self.leftmost_char)
-            row_str = truncate_to_display_width(row_str_left_adj, min(self.rows_w-self.startx, visible_columns_total_width), self.unicode_char_width)
+            # 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
+
+            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
@@ -1025,21 +1088,21 @@ 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)
+                        highlight_cell(idx, j, visible_column_widths, colour_pair_number=25, 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)
+                            highlight_cell(idx, col, visible_column_widths, colour_pair_number=25, 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)
+                            highlight_cell(idx, col, visible_column_widths, colour_pair_number=26, y=y)
             # Higlight cursor row and selected rows
             elif self.highlight_full_row:
                 if self.selections[item[0]]:
@@ -1072,7 +1135,7 @@ class Picker:
             # Draw cursor
             if idx == self.cursor_pos:
                 if self.cell_cursor:
-                    highlight_cell(idx, self.selected_column, visible_column_widths)
+                    highlight_cell(idx, self.selected_column, visible_column_widths, colour_pair_number=5, 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)
             
@@ -1116,8 +1179,10 @@ class Picker:
             self.stdscr.addstr(self.term_h - 1, self.term_w-footer_string_width-1, " "*footer_string_width, curses.color_pair(self.colours_start+24))
             self.stdscr.addstr(self.term_h - 1, self.term_w-footer_string_width-1, f"{disp_string}", curses.color_pair(self.colours_start+24))
 
-        if self.split_right and self.split_right_function(self.stdscr, 0,0,0,0,{},[],[],"",test=True):
-            self.right_pane_previous_data = self.split_right_function(
+        if self.split_right and len(self.right_panes):
+            draw_pane = self.right_panes[self.right_pane_index]["display"]
+            data = self.right_panes[self.right_pane_index]["data"]
+            draw_pane(
                 self.stdscr, 
                 x = self.rows_w,
                 y = self.top_space - int(bool(self.show_header and self.header)),
@@ -1126,7 +1191,7 @@ class Picker:
                 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=self.split_right_data,
+                data=data,
             )
         
         self.stdscr.refresh()
@@ -1290,12 +1355,9 @@ class Picker:
             "sheet_name":                       self.sheet_name,
             "sheet_states":                     self.sheet_states,
             "split_right":                      self.split_right,
-            "split_right_proportion":           self.split_right_proportion,
-            "split_right_function":             self.split_right_function,
-            "split_right_auto_refresh":         self.split_right_auto_refresh,
-            "split_right_refresh_data_timer":   self.split_right_refresh_data_timer,
-            "split_right_refresh_data":         self.split_right_refresh_data,
-            "split_right_data":                 self.split_right_data,
+            "right_panes":                      self.right_panes,
+            "right_pane_index":                 self.right_pane_index,
+
         }
         return function_data
 
@@ -1331,8 +1393,6 @@ class Picker:
             "centre_in_cols",
             "centre_in_terminal",
             "split_right",
-            "split_right_proportion",
-            "split_right_function",
         ]
 
         for var in variables:
@@ -1426,6 +1486,7 @@ class Picker:
             "number_columns": False,
             "reset_colours": False,
             "split_right": False,
+            "cell_cursor": False,
         }
         while True:
             h, w = stdscr.getmaxyx()
@@ -1457,6 +1518,8 @@ class Picker:
 
         if not message: message = "!!"
         submenu_items = ["  "+message[i*message_width:(i+1)*message_width] for i in range(len(message)//message_width+1)]
+        for i in range(len(submenu_items)):
+            submenu_items[i] = f"{submenu_items[i]:^{message_width}}"
 
         notification_remap_keys = { 
             curses.KEY_RESIZE: curses.KEY_F5,
@@ -1482,6 +1545,7 @@ class Picker:
                 "cancel_is_back": True,
                 "reset_colours": False,
                 "split_right": False,
+                "cell_cursor": False,
 
             }
             OptionPicker = Picker(submenu_win, **notification_data)
@@ -1622,6 +1686,9 @@ class Picker:
                 elif setting == "pane":
                     self.toggle_right_pane()
 
+                elif setting == "pane_cycle":
+                    self.cycle_right_pane()
+
                 elif setting.startswith("cwd="):
                     os.chdir(os.path.expandvars(os.path.expanduser(setting[len("cwd="):])))
                 elif setting.startswith("hl"):
@@ -2240,10 +2307,16 @@ class Picker:
             self.load_sheet(self.loaded_file, sheet_number=self.sheet_index)
 
     def toggle_right_pane(self):
-        if self.split_right_function(self.stdscr, 0,0,0,0,{},[],[],"",test=True):
+        if len(self.right_panes):
             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())
 
 
+    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)
+
     def run(self) -> Tuple[list[int], str, dict]:
         """ Run the picker. """
         self.logger.info(f"function: run()")
@@ -2257,7 +2330,7 @@ class Picker:
 
         initial_time = time.time()
         initial_time_footer = time.time()-self.footer_timer
-        initial_split_time = time.time()-self.split_right_refresh_data_timer
+        initial_split_time = time.time()-200
 
         if self.startup_notification:
             self.notification(self.stdscr, message=self.startup_notification)
@@ -2293,8 +2366,9 @@ class Picker:
 
         h, w = self.stdscr.getmaxyx()
         self.term_h, self.term_w = self.stdscr.getmaxyx()
-        if self.split_right and self.split_right_function(self.stdscr, 0,0,0,0,{},[],[],"",test=True):
-            self.rows_w, self.rows_h = int(self.term_w*self.split_right_proportion), 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
         def terminal_resized(old_w, old_h) -> bool:
@@ -2318,8 +2392,10 @@ class Picker:
 
             h, w = self.stdscr.getmaxyx()
             self.term_h, self.term_w = self.stdscr.getmaxyx()
-            if self.split_right and self.split_right_function(self.stdscr, 0,0,0,0,{},[],[],"",test=True):
-                self.rows_w, self.rows_h = int(self.term_w*self.split_right_proportion), 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
 
@@ -2374,8 +2450,10 @@ class Picker:
                 initial_time_footer = time.time()
                 self.draw_screen(self.indexed_items, self.highlights)
 
-            if self.split_right and self.split_right_auto_refresh and ((time.time() - initial_split_time) > self.split_right_refresh_data_timer):
-                self.split_right_data = self.split_right_refresh_data(self.split_right_data, self.get_function_data())
+            if self.split_right and len(self.right_panes) and self.right_panes[self.right_pane_index]["auto_refresh"] and ((time.time() - 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())
                 initial_split_time = time.time()
 
             if self.check_key("help", key, self.keys_dict):
@@ -2870,8 +2948,8 @@ 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:
-                        self.leftmost_char = self.leftmost_char+5
+                    if row_width-self.leftmost_char >= self.rows_w-self.startx-5:
+                        self.leftmost_char += 5
 
             elif self.check_key("scroll_left", key, self.keys_dict):
                 self.logger.info(f"key_function scroll_left")
@@ -2885,17 +2963,18 @@ 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)
+                # 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)
+                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
 
@@ -2990,7 +3069,6 @@ 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)
-
                 self.draw_screen(self.indexed_items, self.highlights)
 
 
@@ -3243,6 +3321,9 @@ class Picker:
             elif self.check_key("toggle_right_pane", key, self.keys_dict):
                 self.toggle_right_pane()
 
+            elif self.check_key("cycle_right_pane", key, self.keys_dict):
+                self.cycle_right_pane()
+
             elif self.check_key("pipe_input", key, self.keys_dict):
                 self.logger.info(f"key_function pipe_input")
                 # usrtxt = "xargs -d '\n' -I{}  "
@@ -3766,20 +3847,54 @@ def main() -> None:
     # function_data["debug"] = True
     # function_data["debug_level"] = 1
 
-
-    # function_data["split_right"] = True
-    # function_data["split_right_proportion"] = 2/3
-    # function_data["split_right_refresh_data"] = data_refresh_randint_title
-    # function_data["split_right_function"] = right_split_display_list
-    # function_data["split_right_data"] = ["Files", [str(x) for x in range(100)]]
-
-
-    # function_data["split_right_refresh_data"] = get_dl
-
-
-    # function_data["split_right_function"] = right_split_file_attributes
-    # function_data["split_right_auto_refresh"] = True
-    # function_data["split_right_function"] = right_split_graph
+    function_data["split_right"] = False
+    function_data["right_panes"] = [
+        # Graph or random numbers generated each second
+        {
+            "proportion": 2/3,
+            "auto_refresh": True,
+            "get_data": data_refresh_randint,
+            "display": right_split_graph,
+            "data": [],
+            "refresh_time": 1.0,
+        },
+        # list of numbers
+        {
+            "proportion": 2/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
+        {
+            "proportion": 2/3,
+            "auto_refresh": False,
+            "get_data": lambda data, state: [],
+            "display": right_split_file_attributes,
+            "data": ["Files", [str(x) for x in range(100)]],
+            "refresh_time": 1.0,
+        },
+        # List of random numbers generated each second
+        {
+            "proportion": 1/2,
+            "auto_refresh": True,
+            "get_data": data_refresh_randint_title,
+            "display": right_split_display_list,
+            "data": ["Files", []],
+            "refresh_time": 0.1,
+        },
+        # 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": 0.1,
+        },
+    ]
 
     stdscr = start_curses()
     try:

listpick/pane/pane_functions.py

@@ -29,6 +29,12 @@ def right_split_file_attributes(stdscr, x, y, w, h, state, row, cell, past_data:
     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])
@@ -58,6 +64,14 @@ def right_split_graph(stdscr, x, y, w, h, state, row, cell, past_data: list = []
     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:
@@ -66,6 +80,7 @@ def right_split_graph(stdscr, x, y, w, h, state, row, cell, past_data: list = []
         return None
 
 
+
     # x_vals, y_vals = list(range(100)), [x**2 for x in range(100)]
     if data in [[], {}, None]:
         return None
@@ -96,6 +111,14 @@ def right_split_display_list(stdscr, x, y, w, h, state, row, cell, past_data: li
     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
 

listpick/ui/build_help.py

@@ -143,11 +143,12 @@ 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",
     }
     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_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"],
+        "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"],
         "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 sort:": [ "filter_input", "search_input", "continue_search_forward", "continue_search_backward", ] ,

listpick/ui/keys.py

@@ -87,6 +87,7 @@ picker_keys = {
     # "sheet_next":                           [],
     # "sheet_prev":                           [],
     "toggle_right_pane":                             [ord("'")], 
+    "cycle_right_pane":                             [ord('"')], 
 }
 
 

listpick/ui/picker_colours.py

@@ -340,7 +340,7 @@ def get_notification_colours(pick:int=0) -> Dict[str, int]:
     else:
         colours['background'] = 237
         colours['unselected_bg'] = 237
-        colours['cursor_bg'] = 237
+        colours['cursor_bg'] = 238
         colours['selected_bg'] = 237
 
     return colours

listpick/utils/utils.py

@@ -34,7 +34,7 @@ def clip_left(text, n):
         if width + char_width > n:
             return text[i:]
         width += char_width
-    return text  # If the total width is less than n, return the full string
+    return ""
 
 def truncate_to_display_width(text: str, max_column_width: int, centre=False, unicode_char_width: bool = True) -> str:
     """ 

{listpick-0.1.15.6.dist-info → listpick-0.1.15.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: listpick
-Version: 0.1.15.6
+Version: 0.1.15.8
 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

{listpick-0.1.15.6.dist-info → listpick-0.1.15.8.dist-info}/RECORD

@@ -1,17 +1,17 @@
 listpick/__init__.py,sha256=ExXc97-bibodH--wlwpQivl0zCNR5D1hvpvrf7OBofU,154
 listpick/__main__.py,sha256=wkCjDdqw093W27yWwnlC3nG_sMRKaIad7hHHWy0RBgY,193
-listpick/listpick_app.py,sha256=AYZNXy4Gc-_F4kLXiPB1-321mkfl3WxP9IRkM3VcYfk,194065
+listpick/listpick_app.py,sha256=NAD1T5i2CDD_WOvHk5ZjJXRpdeN_76ZVRQA8cveK4hk,199678
 listpick/pane/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 listpick/pane/get_data.py,sha256=21PTDXt9HP-4vZV4QUM8sidTqDEaKnKCDshl3-cSRCo,2255
-listpick/pane/pane_functions.py,sha256=7xynpd3HjZnt6s9W0ZsJlrmYvGCMstAI5OJ7EuQSzdg,3092
+listpick/pane/pane_functions.py,sha256=Hpc6wSFeiTmQTyO6n13muenarZMvzFw0OCmjJJy2lTY,3910
 listpick/pane/pane_utils.py,sha256=tMp8KlFng6ZQgNjd8iFrl1zWZLPXMH_Y1A_QeuQYAk0,2537
 listpick/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-listpick/ui/build_help.py,sha256=NY-bDVV5NYQ2mEJo3-tTUsFpG7R6hwROPZPgc8NGfA0,10451
+listpick/ui/build_help.py,sha256=fDEURRb51slvK7rpk2iPWcJAwIAVigv8dp6T4cziZb4,10544
 listpick/ui/footer.py,sha256=OH27JLGvvq9TlUsI30ODG6cHvjm7NTGSbXvF6lN1qiY,15089
 listpick/ui/help_screen.py,sha256=zbfGIgb-IXtATpl4_Sx7nPbsnRXZ7eiMYlCKGS9EFmw,5608
 listpick/ui/input_field.py,sha256=ylf3fiLXdAD4pueHWfzIrlwaRb9f5zm8f1UGkEPBxgM,30539
-listpick/ui/keys.py,sha256=82uzU_cMo6NFHVi3P6cP0uE2ZN0h1EaVLYIVKuB26AU,13494
-listpick/ui/picker_colours.py,sha256=wftDxmUI6tGmOIPwBe4rUUsrPTtpFGgztptCifa_tqA,12287
+listpick/ui/keys.py,sha256=nAmUn95UGuqh3QQMHWsPsXWW3or2oVMVlkzJV1t3zLQ,13559
+listpick/ui/picker_colours.py,sha256=wq6FhXELejCoeBunWQgk9bsD0lLA3xM-I9WzZdWfWFE,12287
 listpick/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 listpick/utils/clipboard_operations.py,sha256=ORdNm2kgGbfs51xJSvgJPERgoSmBgT11axuMkvSoP9A,3133
 listpick/utils/config.py,sha256=MEnAZg2Rhfl38XofEIN0uoVAOY7I0ftc79Evk3fOiVw,1654
@@ -28,10 +28,10 @@ listpick/utils/searching.py,sha256=Xk5UIqamNHL2L90z3ACB_Giqdpi9iRKoAJ6pKaqaD7Q,3
 listpick/utils/sorting.py,sha256=WZZiVlVA3Zkcpwji3U5SNFlQ14zVEk3cZJtQirBkecQ,5329
 listpick/utils/table_to_list_of_lists.py,sha256=XBj7eGBDF15BRME-swnoXyOfZWxXCxrXp0pzsBfcJ5g,12224
 listpick/utils/user_input.py,sha256=oyJZPAwA7UGAclPhdPL44tKnPIVNHWhX-tZEnCdBKC0,4318
-listpick/utils/utils.py,sha256=McOl9uT3jh7l4TIWeSd8ZGjK_e7r0YZF0Gl20yI6fl0,13873
-listpick-0.1.15.6.dist-info/licenses/LICENSE.txt,sha256=2mP-MRHJptADDNE9VInMNg1tE-C6Qv93Z4CCQKrpg9w,1061
-listpick-0.1.15.6.dist-info/METADATA,sha256=NHtilLmI6XfhHiraJOWmAddA8c-3vvpgGUW496LE5CU,8131
-listpick-0.1.15.6.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-listpick-0.1.15.6.dist-info/entry_points.txt,sha256=-QCf_BKIkUz35Y9nkYpjZWs2Qg0KfRna2PAs5DnF6BE,43
-listpick-0.1.15.6.dist-info/top_level.txt,sha256=5mtsGEz86rz3qQDe0D463gGjAfSp6A3EWg4J4AGYr-Q,9
-listpick-0.1.15.6.dist-info/RECORD,,
+listpick/utils/utils.py,sha256=QptLnqT15Z3G7xoq-6Q8e4-aZRFClTdb3h0l42di11s,13810
+listpick-0.1.15.8.dist-info/licenses/LICENSE.txt,sha256=2mP-MRHJptADDNE9VInMNg1tE-C6Qv93Z4CCQKrpg9w,1061
+listpick-0.1.15.8.dist-info/METADATA,sha256=RQbxnHkBzede_XRsNo2USmf9wigm9AZI6ACLsw5ZJBQ,8131
+listpick-0.1.15.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+listpick-0.1.15.8.dist-info/entry_points.txt,sha256=-QCf_BKIkUz35Y9nkYpjZWs2Qg0KfRna2PAs5DnF6BE,43
+listpick-0.1.15.8.dist-info/top_level.txt,sha256=5mtsGEz86rz3qQDe0D463gGjAfSp6A3EWg4J4AGYr-Q,9
+listpick-0.1.15.8.dist-info/RECORD,,