tksheet 7.4.3__py3-none-any.whl → 7.4.5__py3-none-any.whl

tksheet/main_table.py

@@ -50,7 +50,6 @@ from .functions import (
     consecutive_ranges,
     data_to_displayed_idxs,
     diff_gen,
-    diff_list,
     down_cell_within_box,
     event_dict,
     event_has_char_key,
@@ -72,6 +71,7 @@ from .functions import (
     mod_span,
     mod_span_widget,
     move_elements_by_mapping,
+    move_elements_by_mapping_gen,
     new_tk_event,
     next_cell,
     push_n,
@@ -122,7 +122,7 @@ class MainTable(tk.Canvas):
         self.PAR_height = 0
         self.cells_cache = None
         self.table_txt_height, self.index_txt_height, self.header_txt_height = 0, 0, 0
-        self.scrollregion = tuple()
+        self.scrollregion = ()
         self.current_cursor = ""
         self.ctrl_b1_pressed = False
         self.b1_pressed_loc = None
@@ -164,7 +164,7 @@ class MainTable(tk.Canvas):
         self.hidd_boxes = set()
 
         self.selection_boxes = {}
-        self.selected = tuple()
+        self.selected = ()
         self.named_spans = {}
         self.reset_tags()
         self.cell_options = {}
@@ -305,14 +305,13 @@ class MainTable(tk.Canvas):
             self.data = kwargs["data_reference"]
         else:
             self.data = []
-        if not self.data:
-            if (
-                isinstance(kwargs["total_rows"], int)
-                and isinstance(kwargs["total_cols"], int)
-                and kwargs["total_rows"] > 0
-                and kwargs["total_cols"] > 0
-            ):
-                self.data = [list(repeat("", kwargs["total_cols"])) for i in range(kwargs["total_rows"])]
+        if not self.data and (
+            isinstance(kwargs["total_rows"], int)
+            and isinstance(kwargs["total_cols"], int)
+            and kwargs["total_rows"] > 0
+            and kwargs["total_cols"] > 0
+        ):
+            self.data = [list(repeat("", kwargs["total_cols"])) for i in range(kwargs["total_rows"])]
         _header = kwargs["header"] if kwargs["header"] is not None else kwargs["headers"]
         if isinstance(_header, int):
             self._headers = _header
@@ -336,14 +335,14 @@ class MainTable(tk.Canvas):
         self.set_col_positions(itr=[])
         self.set_row_positions(itr=[])
         self.display_rows(
-            rows=kwargs["displayed_rows"],
+            rows=kwargs["displayed_rows"] if isinstance(kwargs["displayed_rows"], list) else [],
             all_rows_displayed=kwargs["all_rows_displayed"],
             reset_row_positions=False,
             deselect_all=False,
         )
         self.reset_row_positions()
         self.display_columns(
-            columns=kwargs["displayed_columns"],
+            columns=kwargs["displayed_columns"] if isinstance(kwargs["displayed_columns"], list) else [],
             all_columns_displayed=kwargs["all_columns_displayed"],
             reset_col_positions=False,
             deselect_all=False,
@@ -551,15 +550,7 @@ class MainTable(tk.Canvas):
                     self.set_currently_selected(row, column, item=item)
                 else:
                     self.select_cell(row, column, redraw=False)
-            if not self.see(
-                row,
-                column,
-                keep_yscroll=False,
-                keep_xscroll=False,
-                bottom_right_corner=False,
-                check_cell_visibility=True,
-                redraw=True,
-            ):
+            if not self.see(row, column):
                 self.refresh()
         return coords
 
@@ -817,7 +808,7 @@ class MainTable(tk.Canvas):
         if self.selected.type_ in ("cells", "columns"):
             for rn in range(maxrows):
                 row = []
-                for r1, c1, r2, c2 in boxes:
+                for r1, c1, _, c2 in boxes:
                     datarn = (r1 + rn) if self.all_rows_displayed else self.displayed_rows[r1 + rn]
                     for c in range(c1, c2):
                         datacn = self.datacn(c)
@@ -932,19 +923,21 @@ class MainTable(tk.Canvas):
     def sort_boxes(
         self,
         event: tk.Event | None = None,
-        boxes: AnyIter[int, int, int, int] | None = None,
+        boxes: dict[tuple[int, int, int, int], Literal["cells", "rows", "columns"]] | None = None,
         reverse: bool = False,
         row_wise: bool = False,
         validation: bool = True,
         key: Callable | None = None,
         undo: bool = True,
     ) -> EventDataDict:
-        if boxes is None:
+        if not boxes:
             boxes = self.get_boxes()
         if not boxes:
-            boxes = [(0, 0, len(self.row_positions) - 1, len(self.col_positions) - 1)]
+            boxes = {Box_nt(0, 0, len(self.row_positions) - 1, len(self.col_positions) - 1): "cells"}
         event_data = self.new_event_dict("edit_table", boxes=boxes)
         try_binding(self.extra_begin_sort_cells_func, event_data)
+        if key is None:
+            key = self.PAR.ops.sort_key
         for r1, c1, r2, c2 in boxes:
             data = sort_selection(
                 [[self.get_cell_data(self.datarn(r), self.datacn(c)) for c in range(c1, c2)] for r in range(r1, r2)],
@@ -1041,23 +1034,21 @@ class MainTable(tk.Canvas):
         added_rows = 0
         added_cols = 0
         total_data_cols = None
-        if self.PAR.ops.paste_can_expand_x:
-            if selected_c + new_data_numcols > len(self.col_positions) - 1:
-                total_data_cols = self.equalize_data_row_lengths()
-                added_cols = selected_c + new_data_numcols - len(self.col_positions) + 1
-                if (
-                    isinstance(self.PAR.ops.paste_insert_column_limit, int)
-                    and self.PAR.ops.paste_insert_column_limit < len(self.col_positions) - 1 + added_cols
-                ):
-                    added_cols = self.PAR.ops.paste_insert_column_limit - len(self.col_positions) - 1
-        if self.PAR.ops.paste_can_expand_y:
-            if selected_r + new_data_numrows > len(self.row_positions) - 1:
-                added_rows = selected_r + new_data_numrows - len(self.row_positions) + 1
-                if (
-                    isinstance(self.PAR.ops.paste_insert_row_limit, int)
-                    and self.PAR.ops.paste_insert_row_limit < len(self.row_positions) - 1 + added_rows
-                ):
-                    added_rows = self.PAR.ops.paste_insert_row_limit - len(self.row_positions) - 1
+        if self.PAR.ops.paste_can_expand_x and selected_c + new_data_numcols > len(self.col_positions) - 1:
+            total_data_cols = self.equalize_data_row_lengths()
+            added_cols = selected_c + new_data_numcols - len(self.col_positions) + 1
+            if (
+                isinstance(self.PAR.ops.paste_insert_column_limit, int)
+                and self.PAR.ops.paste_insert_column_limit < len(self.col_positions) - 1 + added_cols
+            ):
+                added_cols = self.PAR.ops.paste_insert_column_limit - len(self.col_positions) - 1
+        if self.PAR.ops.paste_can_expand_y and selected_r + new_data_numrows > len(self.row_positions) - 1:
+            added_rows = selected_r + new_data_numrows - len(self.row_positions) + 1
+            if (
+                isinstance(self.PAR.ops.paste_insert_row_limit, int)
+                and self.PAR.ops.paste_insert_row_limit < len(self.row_positions) - 1 + added_rows
+            ):
+                added_rows = self.PAR.ops.paste_insert_row_limit - len(self.row_positions) - 1
         if selected_c + new_data_numcols > len(self.col_positions) - 1:
             adjusted_new_data_numcols = len(self.col_positions) - 1 - selected_c
         else:
@@ -1200,14 +1191,8 @@ class MainTable(tk.Canvas):
                     event_data=event_data,
                     mod_event_boxes=False,
                 )
-        if added_rows:
-            selboxr = selected_r + new_data_numrows
-        else:
-            selboxr = selected_r_adjusted_new_data_numrows
-        if added_cols:
-            selboxc = selected_c + new_data_numcols
-        else:
-            selboxc = selected_c_adjusted_new_data_numcols
+        selboxr = selected_r + new_data_numrows if added_rows else selected_r_adjusted_new_data_numrows
+        selboxc = selected_c + new_data_numcols if added_cols else selected_c_adjusted_new_data_numcols
         self.deselect("all", redraw=False)
         self.set_currently_selected(
             *curr_coords,
@@ -1223,15 +1208,7 @@ class MainTable(tk.Canvas):
         )
         event_data["selection_boxes"] = self.get_boxes()
         event_data["selected"] = self.selected
-        self.see(
-            r=selected_r,
-            c=selected_c,
-            keep_yscroll=False,
-            keep_xscroll=False,
-            bottom_right_corner=False,
-            check_cell_visibility=True,
-            redraw=False,
-        )
+        self.see(selected_r, selected_c, redraw=False)
         self.refresh()
         if event_data["cells"]["table"] or event_data["added"]["rows"] or event_data["added"]["columns"]:
             self.undo_stack.append(stored_event_dict(event_data))
@@ -1287,26 +1264,36 @@ class MainTable(tk.Canvas):
         data_indexes: bool = False,
     ) -> tuple[dict[int, int], dict[int, int], int, dict[int, int]]:
         if not data_indexes or self.all_columns_displayed:
-            disp_new_idxs = get_new_indexes(move_to=move_to, to_move=to_move)
+            disp_new_idxs = get_new_indexes(
+                move_to=move_to,
+                to_move=to_move,
+            )
+            data_new_idxs = dict(disp_new_idxs)
         else:
             disp_new_idxs = {}
+            data_new_idxs = get_new_indexes(
+                move_to=move_to,
+                to_move=to_move,
+            )
         # at_least_cols should not be len in this case as move_to can be len
         fix_len = (move_to - 1) if move_to else move_to
         if not self.all_columns_displayed and not data_indexes:
             fix_len = self.datacn(fix_len)
         totalcols = self.equalize_data_row_lengths(at_least_cols=fix_len)
-        data_new_idxs = get_new_indexes(move_to=move_to, to_move=to_move)
         if not self.all_columns_displayed and not data_indexes:
-            data_new_idxs = dict(
-                zip(
-                    move_elements_by_mapping(
+            keep = set(map(self.datacn, to_move))
+            data_new_idxs = {
+                k: v
+                for k, v in zip(
+                    move_elements_by_mapping_gen(
                         self.displayed_columns,
                         data_new_idxs,
                         dict(zip(data_new_idxs.values(), data_new_idxs)),
                     ),
                     self.displayed_columns,
-                ),
-            )
+                )
+                if k in keep
+            }
         return data_new_idxs, dict(zip(data_new_idxs.values(), data_new_idxs)), totalcols, disp_new_idxs
 
     def move_columns_adjust_options_dict(
@@ -1338,7 +1325,7 @@ class MainTable(tk.Canvas):
 
         if move_widths and disp_new_idxs:
             self.set_col_positions(
-                itr=move_elements_by_mapping(
+                itr=move_elements_by_mapping_gen(
                     self.get_column_widths(),
                     disp_new_idxs,
                     dict(
@@ -1409,7 +1396,7 @@ class MainTable(tk.Canvas):
                         "c",
                     )
                     # add cell/col kwargs for columns that are new to the span
-                    old_span_idxs = set(full_new_idxs[k] for k in range(span["from_c"], oldupto_colrange))
+                    old_span_idxs = {full_new_idxs[k] for k in range(span["from_c"], oldupto_colrange)}
                     for k in range(newfrom, newupto_colrange):
                         if k not in old_span_idxs:
                             oldidx = full_old_idxs[k]
@@ -1537,7 +1524,7 @@ class MainTable(tk.Canvas):
             data_new_idxs = {
                 k: v
                 for k, v in zip(
-                    move_elements_by_mapping(
+                    move_elements_by_mapping_gen(
                         self.displayed_rows,
                         data_new_idxs,
                         dict(zip(data_new_idxs.values(), data_new_idxs)),
@@ -1647,7 +1634,7 @@ class MainTable(tk.Canvas):
                         "r",
                     )
                     # add cell/row kwargs for rows that are new to the span
-                    old_span_idxs = set(full_new_idxs[k] for k in range(span["from_r"], oldupto_rowrange))
+                    old_span_idxs = {full_new_idxs[k] for k in range(span["from_r"], oldupto_rowrange)}
                     for k in range(newfrom, newupto_rowrange):
                         if k not in old_span_idxs:
                             oldidx = full_old_idxs[k]
@@ -1730,9 +1717,9 @@ class MainTable(tk.Canvas):
                     # finally, change the span coords
                     span["from_r"], span["upto_r"] = newfrom, newupto
 
-        if move_heights and disp_new_idxs:
+        if (not self.PAR.ops.treeview or not undo_modification) and (move_heights and disp_new_idxs):
             self.set_row_positions(
-                itr=move_elements_by_mapping(
+                itr=move_elements_by_mapping_gen(
                     self.get_row_heights(),
                     disp_new_idxs,
                     dict(
@@ -1788,7 +1775,7 @@ class MainTable(tk.Canvas):
             old_idxs = dict(zip(new_idxs.values(), new_idxs))
         return dict(
             zip(
-                move_elements_by_mapping(tuple(range(max_idx + 1)), new_idxs, old_idxs),
+                move_elements_by_mapping_gen(tuple(range(max_idx + 1)), new_idxs, old_idxs),
                 range(max_idx + 1),
             )
         )
@@ -2036,15 +2023,7 @@ class MainTable(tk.Canvas):
             )
 
         if self.selected:
-            self.see(
-                r=self.selected.row,
-                c=self.selected.column,
-                keep_yscroll=False,
-                keep_xscroll=False,
-                bottom_right_corner=False,
-                check_cell_visibility=True,
-                redraw=False,
-            )
+            self.see(self.selected.row, self.selected.column, redraw=False)
 
         self.refresh()
         return event_data
@@ -2055,18 +2034,27 @@ class MainTable(tk.Canvas):
         c: int | None = None,
         keep_yscroll: bool = False,
         keep_xscroll: bool = False,
-        bottom_right_corner: bool = False,
+        bottom_right_corner: bool | None = None,
         check_cell_visibility: bool = True,
         redraw: bool = True,
         r_pc: float = 0.0,
         c_pc: float = 0.0,
     ) -> bool:
         need_redraw = False
-        yvis, xvis = False, False
-        if check_cell_visibility:
-            yvis, xvis = self.cell_completely_visible(r=r, c=c, separate_axes=True)
-        if not yvis and len(self.row_positions) > 1:
-            if bottom_right_corner:
+        vis_info = self.cell_visibility_info(r, c)
+        yvis, xvis = vis_info["yvis"], vis_info["xvis"]
+        top_left_x, top_left_y, bottom_right_x, bottom_right_y = vis_info["visible_region"]
+        x1, y1, x2, y2 = vis_info["cell_coords"]
+        # y scroll
+        if not check_cell_visibility or (check_cell_visibility and not yvis) and len(self.row_positions) > 1:
+            if bottom_right_corner is None:
+                both_above = y1 < top_left_y and y2 < top_left_y
+                y1_above_y2_below = y1 < top_left_y and y2 > bottom_right_y
+                y1_above_y2_visible = y1 < top_left_y and top_left_y <= y2 <= bottom_right_y
+                brc = not (both_above or y1_above_y2_below or y1_above_y2_visible)
+            else:
+                brc = bottom_right_corner
+            if brc:
                 if r is not None and not keep_yscroll:
                     winfo_height = self.winfo_height()
                     if self.row_positions[r + 1] - self.row_positions[r] > winfo_height:
@@ -2092,8 +2080,16 @@ class MainTable(tk.Canvas):
                     ]
                     self.set_yviews(*args, redraw=False)
                     need_redraw = True
-        if not xvis and len(self.col_positions) > 1:
-            if bottom_right_corner:
+        # x scroll
+        if not check_cell_visibility or (check_cell_visibility and not xvis) and len(self.col_positions) > 1:
+            if bottom_right_corner is None:
+                both_left = x1 < top_left_x and x2 < top_left_x
+                x1_left_x2_right = x1 < top_left_x and x2 > bottom_right_x
+                x1_left_x2_visible = x1 < top_left_x and top_left_x <= x2 <= bottom_right_x
+                brc = not (both_left or x1_left_x2_right or x1_left_x2_visible)
+            else:
+                brc = bottom_right_corner
+            if brc:
                 if c is not None and not keep_xscroll:
                     winfo_width = self.winfo_width()
                     if self.col_positions[c + 1] - self.col_positions[c] > winfo_width:
@@ -2132,17 +2128,24 @@ class MainTable(tk.Canvas):
             0 if not r else self.row_positions[r + 1],
         )
 
-    def cell_completely_visible(
+    def cell_completely_visible(self, r: int | None = 0, c: int | None = 0) -> bool:
+        cx1, cy1, cx2, cy2 = self.get_canvas_visible_area()
+        x1, y1, x2, y2 = self.get_cell_coords(r, c)
+        return cy1 <= y1 and cy2 >= y2 and cx1 <= x1 and cx2 >= x2
+
+    def cell_visibility_info(
         self,
-        r: int | None = 0,
-        c: int | None = 0,
-        separate_axes: bool = False,
-    ) -> bool | tuple[bool, bool]:
+        r: int,
+        c: int,
+    ) -> dict[Literal["yvis", "xvis", "visible_region", "cell_coords"], bool | tuple[int, int, int, int]]:
         cx1, cy1, cx2, cy2 = self.get_canvas_visible_area()
         x1, y1, x2, y2 = self.get_cell_coords(r, c)
-        x_vis = cx1 <= x1 and cx2 >= x2
-        y_vis = cy1 <= y1 and cy2 >= y2
-        return (y_vis, x_vis) if separate_axes else y_vis and x_vis
+        return {
+            "yvis": cy1 <= y1 and cy2 >= y2,
+            "xvis": cx1 <= x1 and cx2 >= x2,
+            "visible_region": (cx1, cy1, cx2, cy2),
+            "cell_coords": (x1, y1, x2, y2),
+        }
 
     def cell_visible(self, r: int = 0, c: int = 0) -> bool:
         cx1, cy1, cx2, cy2 = self.get_canvas_visible_area()
@@ -2289,10 +2292,10 @@ class MainTable(tk.Canvas):
         curr_box = self.selected.fill_iid
         if r == "all" or (r is None and c is None and cell is None):
             self.hide_dropdown_editor_all_canvases()
-            for item, box in self.get_selection_items():
+            for item, _ in self.get_selection_items():
                 self.hide_selection_box(item)
         elif r in ("allrows", "allcols"):
-            for item, box in self.get_selection_items(
+            for item, _ in self.get_selection_items(
                 columns=r == "allcols",
                 rows=r == "allrows",
                 cells=False,
@@ -2517,156 +2520,76 @@ class MainTable(tk.Canvas):
     def arrowkey_UP(self, event: object = None) -> None:
         if not self.selected:
             return
-        if self.selected.type_ == "rows":
-            r = self.selected.row
-            if r and self.RI.row_selection_enabled:
-                if self.cell_completely_visible(r=r - 1, c=0):
-                    self.RI.select_row(r - 1, redraw=True)
-                else:
-                    self.RI.select_row(r - 1)
-                    self.see(r - 1, 0, keep_xscroll=True, check_cell_visibility=False)
-        elif self.selected.type_ in ("cells", "columns"):
-            r = self.selected.row
-            c = self.selected.column
-            if not r and self.CH.col_selection_enabled and not self.cell_completely_visible(r=r, c=c):
-                self.see(r, c, check_cell_visibility=False)
-            elif r and (self.single_selection_enabled or self.toggle_selection_enabled):
-                if self.cell_completely_visible(r=r - 1, c=c):
-                    self.select_cell(r - 1, c, redraw=True)
-                else:
-                    self.select_cell(r - 1, c)
-                    self.see(r - 1, c, keep_xscroll=True, check_cell_visibility=False)
+        r = self.selected.row
+        c = self.selected.column
+        if not r:
+            self.see(r, c)
+        else:
+            self.see(r - 1, c, redraw=False)
+            if self.selected.type_ == "rows" and self.RI.row_selection_enabled:
+                self.RI.select_row(r - 1, redraw=True)
 
-    def arrowkey_DOWN(self, event: object = None) -> None:
+            elif self.selected.type_ in ("cells", "columns") and (
+                self.single_selection_enabled or self.toggle_selection_enabled
+            ):
+                self.select_cell(r - 1, c, redraw=True)
+
+    def arrowkey_LEFT(self, event: object = None) -> None:
         if not self.selected:
             return
-        if self.selected.type_ == "rows":
-            r = self.selected.row
-            if r < len(self.row_positions) - 2 and self.RI.row_selection_enabled:
-                if self.cell_completely_visible(r=r + 1, c=0):
-                    self.RI.select_row(r + 1, redraw=True)
-                else:
-                    self.RI.select_row(r + 1)
-                    self.see(
-                        r + 1,
-                        0,
-                        keep_xscroll=True,
-                        bottom_right_corner=False if self.PAR.ops.arrow_key_down_right_scroll_page else True,
-                        check_cell_visibility=False,
-                    )
-
-        elif self.selected.type_ == "columns":
-            c = self.selected.column
-            if self.single_selection_enabled or self.toggle_selection_enabled:
-                if self.selected.row == len(self.row_positions) - 2:
-                    r = self.selected.row
-                else:
-                    r = self.selected.row + 1
-                if self.cell_completely_visible(r=r, c=c):
-                    self.select_cell(r, c, redraw=True)
-                else:
-                    self.select_cell(r, c)
-                    self.see(
-                        r,
-                        c,
-                        check_cell_visibility=False,
-                    )
+        r = self.selected.row
+        c = self.selected.column
+        if not c:
+            self.see(r, c)
         else:
-            r = self.selected.row
-            c = self.selected.column
-            if r < len(self.row_positions) - 2 and (self.single_selection_enabled or self.toggle_selection_enabled):
-                if self.cell_completely_visible(r=r + 1, c=c):
-                    self.select_cell(r + 1, c, redraw=True)
-                else:
-                    self.select_cell(r + 1, c)
-                    self.see(
-                        r + 1,
-                        c,
-                        keep_xscroll=True,
-                        bottom_right_corner=False if self.PAR.ops.arrow_key_down_right_scroll_page else True,
-                        check_cell_visibility=False,
-                    )
+            self.see(r, c - 1, redraw=False)
+            if self.selected.type_ == "columns":
+                self.CH.select_col(c - 1, redraw=True)
 
-    def arrowkey_LEFT(self, event: object = None) -> None:
+            elif self.selected.type_ in ("cells", "rows"):
+                self.select_cell(r, c - 1, redraw=True)
+
+    def arrowkey_DOWN(self, event: object = None) -> None:
         if not self.selected:
             return
-        if self.selected.type_ == "columns":
-            c = self.selected.column
-            if c and self.CH.col_selection_enabled:
-                if self.cell_completely_visible(r=0, c=c - 1):
-                    self.CH.select_col(c - 1, redraw=True)
-                else:
-                    self.CH.select_col(c - 1)
-                    self.see(
-                        0,
-                        c - 1,
-                        keep_yscroll=True,
-                        bottom_right_corner=True,
-                        check_cell_visibility=False,
-                    )
-        elif self.selected.type_ == "rows" and self.selected.column:
-            self.select_cell(self.selected.row, self.selected.column - 1)
-            self.see(self.selected.row, self.selected.column, check_cell_visibility=True)
-        elif self.selected.type_ == "cells":
-            r = self.selected.row
-            c = self.selected.column
-            if not c and not self.cell_completely_visible(r=r, c=c):
-                self.see(r, c, keep_yscroll=True, check_cell_visibility=False)
-            elif c and (self.single_selection_enabled or self.toggle_selection_enabled):
-                if self.cell_completely_visible(r=r, c=c - 1):
-                    self.select_cell(r, c - 1, redraw=True)
-                else:
-                    self.select_cell(r, c - 1)
-                    self.see(r, c - 1, keep_yscroll=True, check_cell_visibility=False)
+        r = self.selected.row
+        c = self.selected.column
+        if self.selected.row == len(self.row_positions) - 2:
+            self.see(r, c)
+        else:
+            brc = False if self.PAR.ops.arrow_key_down_right_scroll_page else None
+            self.see(
+                r + 1,
+                c,
+                bottom_right_corner=brc,
+                redraw=False,
+            )
+            if self.selected.type_ == "rows":
+                self.RI.select_row(r + 1, redraw=True)
+
+            elif self.selected.type_ in ("cells", "columns"):
+                self.select_cell(r + 1, c, redraw=True)
 
     def arrowkey_RIGHT(self, event: object = None) -> None:
         if not self.selected:
             return
-        if self.selected.type_ == "rows":
-            r = self.selected.row
-            if self.single_selection_enabled or self.toggle_selection_enabled:
-                if self.selected.column == len(self.col_positions) - 2:
-                    c = self.selected.column
-                else:
-                    c = self.selected.column + 1
-                if self.cell_completely_visible(r=r, c=c):
-                    self.select_cell(r, c, redraw=True)
-                else:
-                    self.select_cell(r, c)
-                    self.see(
-                        r,
-                        c,
-                        check_cell_visibility=False,
-                    )
-        elif self.selected.type_ == "columns":
-            c = self.selected.column
-            if c < len(self.col_positions) - 2 and self.CH.col_selection_enabled:
-                if self.cell_completely_visible(r=0, c=c + 1):
-                    self.CH.select_col(c + 1, redraw=True)
-                else:
-                    self.CH.select_col(c + 1)
-                    self.see(
-                        0,
-                        c + 1,
-                        keep_yscroll=True,
-                        bottom_right_corner=False if self.PAR.ops.arrow_key_down_right_scroll_page else True,
-                        check_cell_visibility=False,
-                    )
+        r = self.selected.row
+        c = self.selected.column
+        if self.selected.column == len(self.col_positions) - 2:
+            self.see(r, c)
         else:
-            r = self.selected.row
-            c = self.selected.column
-            if c < len(self.col_positions) - 2 and (self.single_selection_enabled or self.toggle_selection_enabled):
-                if self.cell_completely_visible(r=r, c=c + 1):
-                    self.select_cell(r, c + 1, redraw=True)
-                else:
-                    self.select_cell(r, c + 1)
-                    self.see(
-                        r,
-                        c + 1,
-                        keep_yscroll=True,
-                        bottom_right_corner=False if self.PAR.ops.arrow_key_down_right_scroll_page else True,
-                        check_cell_visibility=False,
-                    )
+            brc = False if self.PAR.ops.arrow_key_down_right_scroll_page else None
+            self.see(
+                r,
+                c + 1,
+                bottom_right_corner=brc,
+                redraw=False,
+            )
+            if self.selected.type_ == "columns":
+                self.CH.select_col(c + 1, redraw=True)
+
+            elif self.selected.type_ in ("cells", "rows"):
+                self.select_cell(r, c + 1, redraw=True)
 
     def shift_arrowkey_select_box(
         self,
@@ -4363,14 +4286,8 @@ class MainTable(tk.Canvas):
         qfont = self.PAR.ops.table_font
         numrows = self.total_data_rows()
         numcols = self.total_data_cols()
-        if self.all_columns_displayed:
-            itercols = range(numcols)
-        else:
-            itercols = self.displayed_columns
-        if self.all_rows_displayed:
-            iterrows = range(numrows)
-        else:
-            iterrows = self.displayed_rows
+        itercols = range(numcols) if self.all_columns_displayed else self.displayed_columns
+        iterrows = range(numrows) if self.all_rows_displayed else self.displayed_rows
         if is_iterable(self._row_index):
             for datarn in iterrows:
                 w_, h = self.RI.get_cell_dimensions(datarn)
@@ -4383,10 +4300,7 @@ class MainTable(tk.Canvas):
         added_w_space = 1 if slim else 7
         for datacn in itercols:
             w = min_column_width if width is None else width
-            if (hw := self.CH.get_cell_dimensions(datacn)[0]) > w:
-                w = hw
-            else:
-                w = min_column_width
+            w = hw if (hw := self.CH.get_cell_dimensions(datacn)[0]) > w else min_column_width
             for datarn in iterrows:
                 if txt := self.get_valid_cell_data_as_str(datarn, datacn, get_displayed=True):
                     qconf(qtxtm, text=txt, font=qfont)
@@ -4489,10 +4403,10 @@ class MainTable(tk.Canvas):
             self.set_row_positions(itr=(h for i, h in enumerate(self.gen_row_heights()) if i not in idxs))
 
     def get_column_widths(self) -> list[int]:
-        return diff_list(self.col_positions)
+        return list(diff_gen(self.col_positions))
 
     def get_row_heights(self) -> list[int]:
-        return diff_list(self.row_positions)
+        return list(diff_gen(self.row_positions))
 
     def gen_column_widths(self) -> Generator[int]:
         return diff_gen(self.col_positions)
@@ -5178,12 +5092,9 @@ class MainTable(tk.Canvas):
                 for datacn in reversed(range(data_ins_col, data_ins_col + numcols))
             }
         else:
-            if headers:
-                start = 1
-            else:
-                start = 0
+            start = 1 if headers else 0
             columns = {
-                datacn: {datarn: v for datarn, v in enumerate(islice(column, start, None))}
+                datacn: dict(enumerate(islice(column, start, None)))
                 for datacn, column in zip(reversed(range(data_ins_col, data_ins_col + numcols)), reversed(columns))
             }
         if widths is None:
@@ -5192,10 +5103,7 @@ class MainTable(tk.Canvas):
                 for c in reversed(range(displayed_ins_col, displayed_ins_col + numcols))
             }
         else:
-            widths = {
-                c: width
-                for c, width in zip(reversed(range(displayed_ins_col, displayed_ins_col + numcols)), reversed(widths))
-            }
+            widths = dict(zip(reversed(range(displayed_ins_col, displayed_ins_col + numcols)), reversed(widths)))
         return columns, header_data, widths
 
     def get_args_for_add_rows(
@@ -5233,10 +5141,7 @@ class MainTable(tk.Canvas):
                 for datarn in reversed(range(data_ins_row, data_ins_row + numrows))
             }
         else:
-            if row_index:
-                start = 1
-            else:
-                start = 0
+            start = 1 if row_index else 0
             rows = {
                 datarn: v[start:] if start and v else v
                 for datarn, v in zip(reversed(range(data_ins_row, data_ins_row + numrows)), reversed(rows))
@@ -5245,10 +5150,7 @@ class MainTable(tk.Canvas):
             default_row_height = self.get_default_row_height()
             heights = {r: default_row_height for r in reversed(range(displayed_ins_row, displayed_ins_row + numrows))}
         else:
-            heights = {
-                r: height
-                for r, height in zip(reversed(range(displayed_ins_row, displayed_ins_row + numrows)), reversed(heights))
-            }
+            heights = dict(zip(reversed(range(displayed_ins_row, displayed_ins_row + numrows)), reversed(heights)))
         return rows, index_data, heights
 
     def copy_options(self) -> dict:
@@ -5340,9 +5242,8 @@ class MainTable(tk.Canvas):
         emit_event: bool = True,
     ) -> EventDataDict:
         event_data = self.new_event_dict("delete_columns", state=True)
-        if not columns:
-            if not (columns := sorted(self.get_selected_cols())):
-                return event_data
+        if not columns and not (columns := sorted(self.get_selected_cols())):
+            return event_data
         if not try_binding(self.extra_begin_del_cols_rc_func, event_data, "begin_delete_columns"):
             return
         if self.all_columns_displayed:
@@ -5425,11 +5326,10 @@ class MainTable(tk.Canvas):
         data_indexes: bool = False,
         undo: bool = True,
         emit_event: bool = True,
-    ) -> EventDataDict:
+    ) -> None | EventDataDict:
         event_data = self.new_event_dict("delete_rows", state=True)
-        if not rows:
-            if not (rows := sorted(self.get_selected_rows())):
-                return
+        if not rows and not (rows := sorted(self.get_selected_rows())):
+            return
         if not try_binding(self.extra_begin_del_rows_rc_func, event_data, "begin_delete_rows"):
             return
         if self.all_rows_displayed:
@@ -5577,13 +5477,13 @@ class MainTable(tk.Canvas):
             elif not isinstance(newheaders, (list, tuple, int)) and index is None:
                 try:
                     self._headers = list(newheaders)
-                except Exception:
+                except ValueError as error:
                     raise ValueError(
                         """
                         New header must be iterable or int \
                         (use int to use a row as the header
                         """
-                    )
+                    ) from error
             if reset_col_positions:
                 self.reset_col_positions()
             elif (
@@ -5626,13 +5526,13 @@ class MainTable(tk.Canvas):
             elif not isinstance(newindex, (list, tuple, int)) and index is None:
                 try:
                     self._row_index = list(newindex)
-                except Exception:
+                except ValueError as error:
                     raise ValueError(
                         """
                         New index must be iterable or int \
                         (use int to use a column as the index
                         """
-                    )
+                    ) from error
             if reset_row_positions:
                 self.reset_row_positions()
             elif (
@@ -6026,7 +5926,7 @@ class MainTable(tk.Canvas):
                         widths[i] = min_column_width
                 if diffs and len(diffs) < len(widths):
                     change = sum(diffs.values()) / (len(widths) - len(diffs))
-                    for i, w in enumerate(widths):
+                    for i in range(len(widths)):
                         if i not in diffs:
                             widths[i] -= change
                 self.col_positions = list(accumulate(chain([0], widths)))
@@ -6053,7 +5953,7 @@ class MainTable(tk.Canvas):
                         heights[i] = min_row_height
                 if diffs and len(diffs) < len(heights):
                     change = sum(diffs.values()) / (len(heights) - len(diffs))
-                    for i, h in enumerate(heights):
+                    for i in range(len(heights)):
                         if i not in diffs:
                             heights[i] -= change
                 self.row_positions = list(accumulate(chain([0], heights)))
@@ -6240,10 +6140,7 @@ class MainTable(tk.Canvas):
                 if self.PAR.ops.horizontal_grid_to_end_of_window:
                     x_grid_stop = scrollpos_right + can_width
                 else:
-                    if last_col_line_pos > scrollpos_right:
-                        x_grid_stop = x_stop + 1
-                    else:
-                        x_grid_stop = x_stop - 1
+                    x_grid_stop = x_stop + 1 if last_col_line_pos > scrollpos_right else x_stop - 1
                 self.redraw_gridline(
                     points=tuple(
                         chain.from_iterable(
@@ -6266,10 +6163,7 @@ class MainTable(tk.Canvas):
                 if self.PAR.ops.vertical_grid_to_end_of_window:
                     y_grid_stop = scrollpos_bot + can_height
                 else:
-                    if last_row_line_pos > scrollpos_bot:
-                        y_grid_stop = y_stop + 1
-                    else:
-                        y_grid_stop = y_stop - 1
+                    y_grid_stop = y_stop + 1 if last_row_line_pos > scrollpos_bot else y_stop - 1
                 self.redraw_gridline(
                     points=tuple(
                         chain.from_iterable(
@@ -6293,10 +6187,7 @@ class MainTable(tk.Canvas):
             sel_cells_bg = color_tup(self.PAR.ops.table_selected_cells_bg)
             sel_cols_bg = color_tup(self.PAR.ops.table_selected_columns_bg)
             sel_rows_bg = color_tup(self.PAR.ops.table_selected_rows_bg)
-            if self.selected:
-                current_loc = (self.selected.row, self.selected.column)
-            else:
-                current_loc = tuple()
+            current_loc = (self.selected.row, self.selected.column) if self.selected else ()
             if self.PAR.ops.alternate_color:
                 alternate_color = Highlight(
                     bg=self.PAR.ops.alternate_color,
@@ -6306,10 +6197,10 @@ class MainTable(tk.Canvas):
                 if self.selected and box_is_single_cell(*self.selected.box) and self.PAR.ops.show_selected_cells_border:
                     dont_blend = current_loc
                 else:
-                    dont_blend = tuple()
+                    dont_blend = ()
             else:
                 alternate_color = None
-                dont_blend = tuple()
+                dont_blend = ()
             if not self.PAR.ops.show_selected_cells_border:
                 override = (
                     color_tup(self.PAR.ops.table_selected_cells_fg),
@@ -6317,7 +6208,7 @@ class MainTable(tk.Canvas):
                     color_tup(self.PAR.ops.table_selected_rows_fg),
                 )
             else:
-                override = tuple()
+                override = ()
             allow_overflow = self.PAR.ops.allow_cell_overflow
             wrap = self.PAR.ops.table_wrap
             cells = self._redraw_precache_cells(
@@ -6514,7 +6405,7 @@ class MainTable(tk.Canvas):
                         self.itemconfig(iid, state="hidden")
                         dct[iid] = False
             if self.PAR.ops.show_selected_cells_border:
-                for iid, box in self.selection_boxes.items():
+                for _, box in self.selection_boxes.items():
                     if box.bd_iid:
                         self.tag_raise(box.bd_iid)
                 if self.selected:
@@ -6576,7 +6467,7 @@ class MainTable(tk.Canvas):
     def reselect_from_get_boxes(
         self,
         boxes: dict,
-        selected: tuple = tuple(),
+        selected: tuple = (),
     ) -> None:
         for (r1, c1, r2, c2), v in boxes.items():
             if r2 < len(self.row_positions) and c2 < len(self.col_positions):
@@ -6610,14 +6501,15 @@ class MainTable(tk.Canvas):
 
         # set current to any existing selection box with coordinates: box
         if isinstance(box, tuple):
-            for item, selection_box in self.get_selection_items(reverse=True):
-                if box == selection_box.coords:
-                    if box_created(box[0] if r is None else r, box[1] if c is None else c, selection_box):
-                        return
+            for _, selection_box in self.get_selection_items(reverse=True):
+                if box == selection_box.coords and box_created(
+                    box[0] if r is None else r, box[1] if c is None else c, selection_box
+                ):
+                    return
 
         # set current to a coordinate, find the top most box there
         if isinstance(r, int) and isinstance(c, int):
-            for item, selection_box in self.get_selection_items(reverse=True):
+            for _, selection_box in self.get_selection_items(reverse=True):
                 if box_created(r, c, selection_box):
                     return
 
@@ -6636,15 +6528,15 @@ class MainTable(tk.Canvas):
     def coords_and_type(self, item: int) -> tuple:
         if item in self.selection_boxes:
             return Box_t(*(self.selection_boxes[item].coords + (self.selection_boxes[item].type_,)))
-        return tuple()
+        return ()
 
     def get_selected_box_bg_fg(self, type_: str) -> tuple:
-        if type_ == "cells":
-            return self.PAR.ops.table_selected_cells_bg, self.PAR.ops.table_selected_box_cells_fg
-        elif type_ == "rows":
-            return self.PAR.ops.table_selected_rows_bg, self.PAR.ops.table_selected_box_rows_fg
-        elif type_ == "columns":
-            return self.PAR.ops.table_selected_columns_bg, self.PAR.ops.table_selected_box_columns_fg
+        type_map = {
+            "cells": (self.PAR.ops.table_selected_cells_bg, self.PAR.ops.table_selected_box_cells_fg),
+            "rows": (self.PAR.ops.table_selected_rows_bg, self.PAR.ops.table_selected_box_rows_fg),
+            "columns": (self.PAR.ops.table_selected_columns_bg, self.PAR.ops.table_selected_box_columns_fg),
+        }
+        return type_map[type_]
 
     def create_currently_selected_box(
         self,
@@ -6701,10 +6593,7 @@ class MainTable(tk.Canvas):
         width: int,
         iid: None | int = None,
     ) -> int:
-        if not self.PAR.ops.rounded_boxes or not x2 - x1 or not y2 - y1:
-            radius = 0
-        else:
-            radius = 5
+        radius = 0 if not self.PAR.ops.rounded_boxes or not x2 - x1 or not y2 - y1 else 5
         coords = rounded_box_coords(
             x1,
             y1,
@@ -6761,7 +6650,7 @@ class MainTable(tk.Canvas):
     def hide_selected(self) -> None:
         if self.selected:
             self.hide_box(self.selected.iid)
-            self.selected = tuple()
+            self.selected = ()
 
     def create_selection_box(
         self,
@@ -7271,7 +7160,7 @@ class MainTable(tk.Canvas):
             self.text_editor.window.set_text(self.text_editor.get() + "" if not isinstance(text, str) else text)
             return False
         self.hide_text_editor()
-        if not self.see(r=r, c=c, check_cell_visibility=True):
+        if not self.see(r, c):
             self.main_table_redraw_grid_and_text(True, True)
         x = self.col_positions[c]
         y = self.row_positions[r]
@@ -7505,13 +7394,7 @@ class MainTable(tk.Canvas):
                     new_r, new_c = None, None
                 if isinstance(new_r, int):
                     self.set_currently_selected(new_r, new_c, item=self.selected.fill_iid)
-                    self.see(
-                        new_r,
-                        new_c,
-                        keep_xscroll=False,
-                        bottom_right_corner=True,
-                        check_cell_visibility=True,
-                    )
+                    self.see(new_r, new_c)
         self.recreate_all_selection_boxes()
         self.hide_text_editor_and_dropdown()
         if event.keysym != "FocusOut":
@@ -7524,17 +7407,11 @@ class MainTable(tk.Canvas):
             r,
             c + 1 if c < len(self.col_positions) - 2 else c,
             bottom_right_corner=True,
-            check_cell_visibility=True,
         )
 
     def select_down(self, r: int, c: int) -> None:
         self.select_cell(r + 1 if r < len(self.row_positions) - 2 else r, c)
-        self.see(
-            r + 1 if r < len(self.row_positions) - 2 else r,
-            c,
-            bottom_right_corner=True,
-            check_cell_visibility=True,
-        )
+        self.see(r + 1 if r < len(self.row_positions) - 2 else r, c)
 
     def tab_key(self, event: object = None) -> str:
         if not self.selected:
@@ -7550,13 +7427,7 @@ class MainTable(tk.Canvas):
         else:
             new_r, new_c = cell_right_within_box(r, c, r1, c1, r2, c2, numrows, numcols)
             self.set_currently_selected(new_r, new_c, item=self.selected.fill_iid)
-        self.see(
-            new_r,
-            new_c,
-            keep_xscroll=False,
-            bottom_right_corner=True,
-            check_cell_visibility=True,
-        )
+        self.see(new_r, new_c, bottom_right_corner=True)
         if not self.PAR.ops.show_selected_cells_border:
             self.refresh()
         return "break"
@@ -7867,7 +7738,7 @@ class MainTable(tk.Canvas):
         datarn: int,
         datacn: int,
         value: object,
-        kwargs: dict = {},
+        kwargs: dict | None = None,
         expand_sheet: bool = True,
     ) -> None:
         if expand_sheet:
@@ -7893,26 +7764,20 @@ class MainTable(tk.Canvas):
                     self.data[datarn][datacn] = value
 
     def get_value_for_empty_cell(self, datarn: int, datacn: int, r_ops: bool = True, c_ops: bool = True) -> object:
-        if self.get_cell_kwargs(
-            datarn,
-            datacn,
-            key="checkbox",
-            cell=r_ops and c_ops,
-            row=r_ops,
-            column=c_ops,
-        ):
-            return False
         kwargs = self.get_cell_kwargs(
             datarn,
             datacn,
-            key="dropdown",
+            key=None,
             cell=r_ops and c_ops,
             row=r_ops,
             column=c_ops,
         )
-        if kwargs and kwargs["validate_input"] and kwargs["values"]:
+        if "checkbox" in kwargs:
+            return False
+        elif (kwargs := kwargs.get("dropdown", {})) and kwargs["validate_input"] and kwargs["values"]:
             return kwargs["values"][0]
-        return ""
+        else:
+            return ""
 
     def get_empty_row_seq(
         self,
@@ -7981,10 +7846,7 @@ class MainTable(tk.Canvas):
                 self.set_cell_data(*key, get_val(*key), expand_sheet=False)
 
     def delete_row_format(self, datarn: Literal["all"] | int = "all", clear_values: bool = False) -> None:
-        if isinstance(datarn, str) and datarn.lower() == "all":
-            itr = gen_formatted(self.row_options)
-        else:
-            itr = (datarn,)
+        itr = gen_formatted(self.row_options) if isinstance(datarn, str) and datarn.lower() == "all" else (datarn,)
         get_val = self.get_value_for_empty_cell
         for datarn in itr:
             try:
@@ -7996,10 +7858,7 @@ class MainTable(tk.Canvas):
                     self.set_cell_data(datarn, datacn, get_val(datarn, datacn), expand_sheet=False)
 
     def delete_column_format(self, datacn: Literal["all"] | int = "all", clear_values: bool = False) -> None:
-        if isinstance(datacn, str) and datacn.lower() == "all":
-            itr = gen_formatted(self.col_options)
-        else:
-            itr = (datacn,)
+        itr = gen_formatted(self.col_options) if isinstance(datacn, str) and datacn.lower() == "all" else (datacn,)
         get_val = self.get_value_for_empty_cell
         for datacn in itr:
             try:
@@ -8072,18 +7931,19 @@ class MainTable(tk.Canvas):
         check_readonly: bool = True,
         ignore_empty: bool = False,
     ) -> bool:
-        if check_readonly and self.get_cell_kwargs(datarn, datacn, key="readonly"):
+        kwargs = self.get_cell_kwargs(datarn, datacn, key=None)
+        if check_readonly and "readonly" in kwargs:
             return False
-        if self.get_cell_kwargs(datarn, datacn, key="format"):
+        elif "format" in kwargs:
             return True
-        if self.cell_equal_to(datarn, datacn, value, ignore_empty=ignore_empty):
-            return False
-        kwargs = self.get_cell_kwargs(datarn, datacn, key="dropdown")
-        if kwargs and kwargs["validate_input"] and value not in kwargs["values"]:
+        elif self.cell_equal_to(datarn, datacn, value, ignore_empty=ignore_empty) or (
+            (dropdown := kwargs.get("dropdown", {})) and dropdown["validate_input"] and value not in dropdown["values"]
+        ):
             return False
-        if self.get_cell_kwargs(datarn, datacn, key="checkbox"):
+        elif "checkbox" in kwargs:
             return is_bool_like(value)
-        return True
+        else:
+            return True
 
     def cell_equal_to(self, datarn: int, datacn: int, value: object, ignore_empty: bool = False, **kwargs) -> bool:
         v = self.get_cell_data(datarn, datacn)
@@ -8118,18 +7978,21 @@ class MainTable(tk.Canvas):
         self,
         datarn: int,
         datacn: int,
-        key: Hashable = "format",
+        key: Hashable | None = "format",
         cell: bool = True,
         row: bool = True,
         column: bool = True,
     ) -> dict:
-        if cell and (datarn, datacn) in self.cell_options and key in self.cell_options[(datarn, datacn)]:
-            return self.cell_options[(datarn, datacn)][key]
-        if row and datarn in self.row_options and key in self.row_options[datarn]:
-            return self.row_options[datarn][key]
-        if column and datacn in self.col_options and key in self.col_options[datacn]:
-            return self.col_options[datacn][key]
-        return {}
+        if cell and (datarn, datacn) in self.cell_options:
+            return (
+                self.cell_options[(datarn, datacn)] if key is None else self.cell_options[(datarn, datacn)].get(key, {})
+            )
+        elif row and datarn in self.row_options:
+            return self.row_options[datarn] if key is None else self.row_options[datarn].get(key, {})
+        elif column and datacn in self.col_options:
+            return self.col_options[datacn] if key is None else self.col_options[datacn].get(key, {})
+        else:
+            return {}
 
     def datacn(self, c: int) -> int:
         return c if self.all_columns_displayed else self.displayed_columns[c]