tksheet 7.1.4__py3-none-any.whl → 7.1.6__py3-none-any.whl

tksheet/main_table.py

@@ -49,7 +49,7 @@ from .formatters import (
     try_to_bool,
 )
 from .functions import (
-    consecutive_chunks,
+    consecutive_ranges,
     decompress_load,
     diff_gen,
     diff_list,
@@ -61,6 +61,7 @@ from .functions import (
     get_seq_without_gaps_at_index,
     index_exists,
     insert_items,
+    int_x_iter,
     is_iterable,
     is_type_int,
     len_to_idx,
@@ -960,12 +961,12 @@ class MainTable(tk.Canvas):
                 )
             )
             if create_selections:
-                for chunk in consecutive_chunks(sorted(disp_new_idxs.values())):
+                for boxst, boxend in consecutive_ranges(sorted(disp_new_idxs.values())):
                     self.create_selection_box(
                         0,
-                        chunk[0],
+                        boxst,
                         len(self.row_positions) - 1,
-                        chunk[-1] + 1,
+                        boxend,
                         "columns",
                         run_binding=True,
                     )
@@ -1181,11 +1182,11 @@ class MainTable(tk.Canvas):
                 )
             )
             if create_selections:
-                for chunk in consecutive_chunks(sorted(disp_new_idxs.values())):
+                for boxst, boxend in consecutive_ranges(sorted(disp_new_idxs.values())):
                     self.create_selection_box(
-                        chunk[0],
+                        boxst,
                         0,
-                        chunk[-1] + 1,
+                        boxend,
                         len(self.col_positions) - 1,
                         "rows",
                         run_binding=True,
@@ -1803,7 +1804,7 @@ class MainTable(tk.Canvas):
                 cells=False,
             ):
                 self.hide_selection_box(item)
-        elif r is not None and c is None and cell is None:
+        elif isinstance(r, int) and c is None and cell is None:
             for item, box in self.get_selection_items(columns=False, cells=False):
                 r1, c1, r2, c2 = box.coords
                 if r >= r1 and r < r2:
@@ -1846,8 +1847,7 @@ class MainTable(tk.Canvas):
                                 "rows",
                                 set_current=resel and to_sel >= r + 1 and to_sel < r2,
                             )
-                    break
-        elif c is not None and r is None and cell is None:
+        elif isinstance(c, int) and r is None and cell is None:
             for item, box in self.get_selection_items(rows=False, cells=False):
                 r1, c1, r2, c2 = box.coords
                 if c >= c1 and c < c2:
@@ -1890,15 +1890,13 @@ class MainTable(tk.Canvas):
                                 "columns",
                                 set_current=resel and to_sel >= c + 1 and to_sel < c2,
                             )
-                    break
-        elif (r is not None and c is not None and cell is None) or cell is not None:
+        elif (isinstance(r, int) and isinstance(c, int) and cell is None) or cell is not None:
             if cell is not None:
                 r, c = cell[0], cell[1]
             for item, box in self.get_selection_items(reverse=True):
                 r1, c1, r2, c2 = box.coords
                 if r >= r1 and c >= c1 and r < r2 and c < c2:
                     self.hide_selection_box(item)
-                    break
         if redraw:
             self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
         sel_event = self.get_select_event(being_drawn_item=self.being_drawn_item)
@@ -1906,7 +1904,51 @@ class MainTable(tk.Canvas):
             try_binding(self.deselection_binding_func, sel_event)
         self.PAR.emit_event("<<SheetSelect>>", data=sel_event)
 
-    def page_UP(self, event=None):
+    def deselect_any(
+        self,
+        rows: Iterator[int] | int | None = None,
+        columns: Iterator[int] | int | None = None,
+        redraw: bool = True,
+    ) -> None:
+        rows = int_x_iter(rows)
+        columns = int_x_iter(columns)
+        if is_iterable(rows) and is_iterable(columns):
+            rows = tuple(consecutive_ranges(sorted(rows)))
+            columns = tuple(consecutive_ranges(sorted(columns)))
+            for item, box in self.get_selection_items(reverse=True):
+                r1, c1, r2, c2 = box.coords
+                hidden = False
+                for rows_st, rows_end in rows:
+                    if hidden:
+                        break
+                    for cols_st, cols_end in columns:
+                        if ((rows_end >= r1 and rows_end <= r2) or (rows_st >= r1 and rows_st < r2)) and (
+                            (cols_end >= c1 and cols_end <= c2) or (cols_st >= c1 and cols_st < c2)
+                        ):
+                            hidden = self.hide_selection_box(item)
+                            break
+        elif is_iterable(rows):
+            rows = tuple(consecutive_ranges(sorted(rows)))
+            for item, box in self.get_selection_items(reverse=True):
+                r1, c1, r2, c2 = box.coords
+                for rows_st, rows_end in rows:
+                    if (rows_end >= r1 and rows_end <= r2) or (rows_st >= r1 and rows_st < r2):
+                        self.hide_selection_box(item)
+                        break
+        elif is_iterable(columns):
+            columns = tuple(consecutive_ranges(sorted(columns)))
+            for item, box in self.get_selection_items(reverse=True):
+                r1, c1, r2, c2 = box.coords
+                for cols_st, cols_end in columns:
+                    if (cols_end >= c1 and cols_end <= c2) or (cols_st >= c1 and cols_st < c2):
+                        self.hide_selection_box(item)
+                        break
+        else:
+            self.deselect()
+        if redraw:
+            self.refresh()
+
+    def page_UP(self, event: object = None) -> None:
         height = self.winfo_height()
         top = self.canvasy(0)
         scrollto_y = top - height
@@ -1935,7 +1977,7 @@ class MainTable(tk.Canvas):
             self.RI.yview(*args)
             self.main_table_redraw_grid_and_text(redraw_row_index=True)
 
-    def page_DOWN(self, event=None):
+    def page_DOWN(self, event: object = None) -> None:
         height = self.winfo_height()
         top = self.canvasy(0)
         scrollto = top + height
@@ -1965,12 +2007,12 @@ class MainTable(tk.Canvas):
             self.RI.yview(*args)
             self.main_table_redraw_grid_and_text(redraw_row_index=True)
 
-    def arrowkey_UP(self, event=None):
+    def arrowkey_UP(self, event: object = None) -> None:
         if not self.selected:
             return
         if self.selected.type_ == "rows":
             r = self.selected.row
-            if r != 0 and self.RI.row_selection_enabled:
+            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:
@@ -1979,64 +2021,17 @@ class MainTable(tk.Canvas):
         elif self.selected.type_ in ("cells", "columns"):
             r = self.selected.row
             c = self.selected.column
-            if r == 0 and self.CH.col_selection_enabled:
+            if not r and self.CH.col_selection_enabled:
                 if not self.cell_completely_visible(r=r, c=0):
-                    self.see(r, c, keep_xscroll=True, check_cell_visibility=False)
-            elif r != 0 and (self.single_selection_enabled or self.toggle_selection_enabled):
+                    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)
 
-    def arrowkey_RIGHT(self, event=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.cell_completely_visible(r=r, c=0):
-                    self.select_cell(r, 0, redraw=True)
-                else:
-                    self.select_cell(r, 0)
-                    self.see(
-                        r,
-                        0,
-                        keep_yscroll=True,
-                        bottom_right_corner=True,
-                        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,
-                    )
-        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,
-                    )
-
-    def arrowkey_DOWN(self, event=None):
+    def arrowkey_DOWN(self, event: object = None) -> None:
         if not self.selected:
             return
         if self.selected.type_ == "rows":
@@ -2071,15 +2066,17 @@ class MainTable(tk.Canvas):
         elif self.selected.type_ == "columns":
             c = self.selected.column
             if self.single_selection_enabled or self.toggle_selection_enabled:
-                if self.cell_completely_visible(r=0, c=c):
-                    self.select_cell(0, c, redraw=True)
+                if self.selected.row == len(self.row_positions) - 2:
+                    r = self.selected.row
                 else:
-                    self.select_cell(0, c)
+                    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(
-                        0,
+                        r,
                         c,
-                        keep_xscroll=True,
-                        bottom_right_corner=True,
                         check_cell_visibility=False,
                     )
         else:
@@ -2113,12 +2110,12 @@ class MainTable(tk.Canvas):
                             check_cell_visibility=False,
                         )
 
-    def arrowkey_LEFT(self, event=None):
+    def arrowkey_LEFT(self, event: object = None) -> None:
         if not self.selected:
             return
         if self.selected.type_ == "columns":
             c = self.selected.column
-            if c != 0 and self.CH.col_selection_enabled:
+            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:
@@ -2130,19 +2127,70 @@ class MainTable(tk.Canvas):
                         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 c == 0 and self.RI.row_selection_enabled:
-                if not self.cell_completely_visible(r=r, c=0):
-                    self.see(r, c, keep_yscroll=True, check_cell_visibility=False)
-            elif c != 0 and (self.single_selection_enabled or self.toggle_selection_enabled):
+            if not c and not self.cell_completely_visible(r=r, c=0):
+                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)
 
+    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,
+                    )
+        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,
+                    )
+
     def key_bindings(self) -> None:
         for widget in (self, self.RI, self.CH, self.TL):
             for binding in self.PAR.ops.copy_bindings:
@@ -3216,8 +3264,6 @@ class MainTable(tk.Canvas):
 
     def ctrl_mousewheel(self, event):
         if event.delta < 0 or event.num == 5:
-            if self.PAR.ops.table_font[1] < 2 or self.PAR.ops.index_font[1] < 2 or self.PAR.ops.header_font[1] < 2:
-                return
             self.zoom_out()
         elif event.delta >= 0 or event.num == 4:
             self.zoom_in()
@@ -3225,16 +3271,22 @@ class MainTable(tk.Canvas):
     def zoom_in(self, event=None):
         self.zoom_font(
             (self.PAR.ops.table_font[0], self.PAR.ops.table_font[1] + 1, self.PAR.ops.table_font[2]),
+            (self.PAR.ops.index_font[0], self.PAR.ops.index_font[1] + 1, self.PAR.ops.index_font[2]),
             (self.PAR.ops.header_font[0], self.PAR.ops.header_font[1] + 1, self.PAR.ops.header_font[2]),
+            "in",
         )
 
     def zoom_out(self, event=None):
+        if self.PAR.ops.table_font[1] < 2 or self.PAR.ops.index_font[1] < 2 or self.PAR.ops.header_font[1] < 2:
+            return
         self.zoom_font(
             (self.PAR.ops.table_font[0], self.PAR.ops.table_font[1] - 1, self.PAR.ops.table_font[2]),
+            (self.PAR.ops.index_font[0], self.PAR.ops.index_font[1] - 1, self.PAR.ops.index_font[2]),
             (self.PAR.ops.header_font[0], self.PAR.ops.header_font[1] - 1, self.PAR.ops.header_font[2]),
+            "out",
         )
 
-    def zoom_font(self, table_font: tuple, header_font: tuple):
+    def zoom_font(self, table_font: tuple, index_font: tuple, header_font: tuple, zoom: Literal["in", "out"]) -> None:
         self.saved_column_widths = {}
         self.saved_row_heights = {}
         # should record position prior to change and then see after change
@@ -3256,7 +3308,7 @@ class MainTable(tk.Canvas):
             table_font,
             reset_row_positions=False,
         )
-        self.set_index_font(table_font)
+        self.set_index_font(index_font)
         self.set_header_font(header_font)
         if self.PAR.ops.set_cell_sizes_on_zoom:
             self.set_all_cell_sizes_to_text()
@@ -3284,18 +3336,18 @@ class MainTable(tk.Canvas):
             )
             self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
             self.recreate_all_selection_boxes()
-        self.refresh_open_window_positions()
-        self.RI.refresh_open_window_positions()
-        self.CH.refresh_open_window_positions()
+        self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
+        self.refresh_open_window_positions(zoom=zoom)
+        self.RI.refresh_open_window_positions(zoom=zoom)
+        self.CH.refresh_open_window_positions(zoom=zoom)
         self.see(
             r,
             c,
             check_cell_visibility=False,
-            redraw=False,
+            redraw=True,
             r_pc=r_pc,
             c_pc=c_pc,
         )
-        self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
 
     def get_txt_w(self, txt, font=None):
         self.txt_measure_canvas.itemconfig(
@@ -3376,7 +3428,7 @@ class MainTable(tk.Canvas):
     def set_table_font_help(self):
         self.table_txt_width, self.table_txt_height = self.get_txt_dimensions("|", self.PAR.ops.table_font)
         self.table_half_txt_height = ceil(self.table_txt_height / 2)
-        if self.table_half_txt_height % 2 == 0:
+        if not self.table_half_txt_height % 2:
             self.table_first_ln_ins = self.table_half_txt_height + 2
         else:
             self.table_first_ln_ins = self.table_half_txt_height + 3
@@ -3404,7 +3456,7 @@ class MainTable(tk.Canvas):
     def set_header_font_help(self):
         self.header_txt_width, self.header_txt_height = self.get_txt_dimensions("|", self.PAR.ops.header_font)
         self.header_half_txt_height = ceil(self.header_txt_height / 2)
-        if self.header_half_txt_height % 2 == 0:
+        if not self.header_half_txt_height % 2:
             self.header_first_ln_ins = self.header_half_txt_height + 2
         else:
             self.header_first_ln_ins = self.header_half_txt_height + 3
@@ -3435,7 +3487,7 @@ class MainTable(tk.Canvas):
     def set_index_font_help(self):
         self.index_txt_width, self.index_txt_height = self.get_txt_dimensions("|", self.PAR.ops.index_font)
         self.index_half_txt_height = ceil(self.index_txt_height / 2)
-        if self.index_half_txt_height % 2 == 0:
+        if not self.index_half_txt_height % 2:
             self.index_first_ln_ins = self.index_half_txt_height + 2
         else:
             self.index_first_ln_ins = self.index_half_txt_height + 3
@@ -3562,19 +3614,22 @@ class MainTable(tk.Canvas):
             else:
                 return False
 
-    def set_all_cell_sizes_to_text(self, include_index: bool = False) -> tuple[list[float], list[float]]:
+    def set_all_cell_sizes_to_text(self, w: int | None = None) -> tuple[list[float], list[float]]:
         min_column_width = int(self.min_column_width)
         min_rh = int(self.min_row_height)
-        w = min_column_width
+        w = min_column_width if w is None else w
         h = min_rh
         rhs = defaultdict(lambda: int(min_rh))
         cws = []
-        itmcon = self.txt_measure_canvas.itemconfig
-        itmbbx = self.txt_measure_canvas.bbox
-        self.txt_measure_canvas.itemconfig(self.txt_measure_canvas_text, font=self.PAR.ops.table_font)
+        qconf = self.txt_measure_canvas.itemconfig
+        qbbox = self.txt_measure_canvas.bbox
+        qtxtm = self.txt_measure_canvas_text
+        qtxth = self.table_txt_height
+        qfont = self.PAR.ops.table_font
         numrows = self.total_data_rows()
+        numcols = self.total_data_cols()
         if self.all_columns_displayed:
-            itercols = range(self.total_data_cols())
+            itercols = range(numcols)
         else:
             itercols = self.displayed_columns
         if self.all_rows_displayed:
@@ -3591,23 +3646,28 @@ class MainTable(tk.Canvas):
                 if h > rhs[datarn]:
                     rhs[datarn] = h
         for datacn in itercols:
-            w, h_ = self.CH.get_cell_dimensions(datacn)
-            if self.all_rows_displayed:
-                iterrows = range(numrows)
+            if (hw := self.CH.get_cell_dimensions(datacn)[0]) > w:
+                w = hw
             for datarn in iterrows:
                 txt = self.get_valid_cell_data_as_str(datarn, datacn, get_displayed=True)
                 if txt:
-                    itmcon(self.txt_measure_canvas_text, text=txt)
-                    b = itmbbx(self.txt_measure_canvas_text)
+                    qconf(qtxtm, text=txt, font=qfont)
+                    b = qbbox(qtxtm)
                     tw = b[2] - b[0] + 7
                     h = b[3] - b[1] + 5
                 else:
                     tw = min_column_width
                     h = min_rh
-                if self.get_cell_kwargs(datarn, datacn, key="dropdown") or self.get_cell_kwargs(
-                    datarn, datacn, key="checkbox"
+                if self.get_cell_kwargs(
+                    datarn,
+                    datacn,
+                    key="dropdown",
+                ) or self.get_cell_kwargs(
+                    datarn,
+                    datacn,
+                    key="checkbox",
                 ):
-                    tw += self.table_txt_height
+                    tw += qtxth
                 if tw > w:
                     w = tw
                 if h < min_rh:
@@ -3621,8 +3681,8 @@ class MainTable(tk.Canvas):
             elif w > self.max_column_width:
                 w = int(self.max_column_width)
             cws.append(w)
-        self.set_row_positions(itr=(height for height in rhs.values()))
-        self.set_col_positions(itr=(width for width in cws))
+        self.set_row_positions(itr=rhs.values())
+        self.set_col_positions(itr=cws)
         self.recreate_all_selection_boxes()
         return self.row_positions, self.col_positions
 
@@ -4193,12 +4253,12 @@ class MainTable(tk.Canvas):
         )
         if create_selections:
             self.deselect("all")
-            for chunk in consecutive_chunks(tuple(reversed(column_widths))):
+            for boxst, boxend in consecutive_ranges(tuple(reversed(column_widths))):
                 self.create_selection_box(
                     0,
-                    chunk[0],
+                    boxst,
                     len(self.row_positions) - 1,
-                    chunk[-1] + 1,
+                    boxend,
                     "columns",
                     run_binding=True,
                 )
@@ -4322,11 +4382,11 @@ class MainTable(tk.Canvas):
         )
         if create_selections:
             self.deselect("all")
-            for chunk in consecutive_chunks(tuple(reversed(row_heights))):
+            for boxst, boxend in consecutive_ranges(tuple(reversed(row_heights))):
                 self.create_selection_box(
-                    chunk[0],
+                    boxst,
                     0,
-                    chunk[-1] + 1,
+                    boxend,
                     len(self.col_positions) - 1,
                     "rows",
                     run_binding=True,
@@ -5606,7 +5666,7 @@ class MainTable(tk.Canvas):
             if r2 < len(self.row_positions) and c2 < len(self.col_positions):
                 self.create_selection_box(r1, c1, r2, c2, v, run_binding=True)
         if selected:
-            self.set_currently_selected(selected.row, selected.column, box=selected.coords)
+            self.set_currently_selected(selected.row, selected.column, box=selected.box)
 
     def set_currently_selected(
         self,
@@ -5689,6 +5749,7 @@ class MainTable(tk.Canvas):
         c: int,
         type_: Literal["cells", "rows", "columns"],
         fill_iid: int,
+        lower_selection_boxes: bool = True,
     ) -> int:
         fill, outline = self.get_selected_box_bg_fg(type_=type_)
         x1 = self.col_positions[c] + 1
@@ -5699,6 +5760,7 @@ class MainTable(tk.Canvas):
         if self.PAR.ops.show_selected_cells_border:
             fill = ""
         else:
+            fill = outline
             outline = ""
         iid = self.display_box(
             x1,
@@ -5719,10 +5781,7 @@ class MainTable(tk.Canvas):
             iid=iid,
             fill_iid=fill_iid,
         )
-        if self.PAR.ops.show_selected_cells_border:
-            self.tag_raise(iid)
-        else:
-            self.tag_lower(iid)
+        if lower_selection_boxes:
             self.lower_selection_boxes()
         return iid
 
@@ -5763,7 +5822,7 @@ class MainTable(tk.Canvas):
             self.hidd_boxes.add(item)
             self.itemconfig(item, state="hidden")
 
-    def hide_selection_box(self, item: int | None, set_current: bool = True) -> None:
+    def hide_selection_box(self, item: int | None, set_current: bool = True) -> bool:
         if item is None:
             return
         box = self.selection_boxes.pop(item)
@@ -5774,6 +5833,7 @@ class MainTable(tk.Canvas):
         if self.selected.fill_iid == item:
             self.hide_selected()
             self.set_current_to_last()
+        return True
 
     def hide_selected(self) -> None:
         if self.selected:
@@ -5871,19 +5931,25 @@ class MainTable(tk.Canvas):
             elif isinstance(set_current, tuple):
                 curr_r = set_current[0]
                 curr_c = set_current[1]
-            self.create_currently_selected_box(curr_r, curr_c, type_, fill_iid)
+            self.create_currently_selected_box(curr_r, curr_c, type_, fill_iid, lower_selection_boxes=False)
         self.lower_selection_boxes()
         if run_binding:
             self.run_selection_binding(type_)
         return fill_iid
 
     def lower_selection_boxes(self) -> None:
-        for iid, box in reversed(self.selection_boxes.items()):
-            self.tag_lower(iid)
-            self.RI.tag_lower(box.index)
-            self.CH.tag_lower(box.header)
-        if self.PAR.ops.show_selected_cells_border and self.selected:
-            self.tag_raise(self.selected.iid)
+        if self.selected:
+            if not self.PAR.ops.show_selected_cells_border:
+                self.tag_lower(self.selected.iid)
+            self.tag_lower("rows")
+            self.tag_lower("columns")
+            self.tag_lower("cells")
+            self.RI.tag_lower("rows")
+            self.RI.tag_lower("cells")
+            self.CH.tag_lower("columns")
+            self.CH.tag_lower("cells")
+            if self.PAR.ops.show_selected_cells_border:
+                self.tag_raise(self.selected.iid)
 
     def recreate_selection_box(
         self,
@@ -6353,13 +6419,11 @@ class MainTable(tk.Canvas):
                     extra_func_key = "Return"
                 elif hasattr(event, "keysym") and event.keysym == "F2":
                     extra_func_key = "F2"
-            datarn = r if self.all_rows_displayed else self.displayed_rows[r]
-            datacn = c if self.all_columns_displayed else self.displayed_columns[c]
             if event is not None and (hasattr(event, "keysym") and event.keysym == "BackSpace"):
                 extra_func_key = "BackSpace"
                 text = ""
             else:
-                text = f"{self.get_cell_data(datarn, datacn, none_to_empty_str = True)}"
+                text = f"{self.get_cell_data(self.datarn(r), self.datacn(c), none_to_empty_str = True)}"
         elif event is not None and (
             (hasattr(event, "char") and event.char.isalpha())
             or (hasattr(event, "char") and event.char.isdigit())
@@ -6403,9 +6467,7 @@ class MainTable(tk.Canvas):
         w = self.col_positions[c + 1] - x + 1
         h = self.row_positions[r + 1] - y + 1
         if text is None:
-            text = f"""{self.get_cell_data(r if self.all_rows_displayed else self.displayed_rows[r],
-                                           c if self.all_columns_displayed else self.displayed_columns[c],
-                                           none_to_empty_str = True)}"""
+            text = f"{self.get_cell_data(self.datarn(r), self.datacn(c), none_to_empty_str = True)}"
         bg, fg = self.PAR.ops.table_bg, self.PAR.ops.table_fg
         kwargs = {
             "menu_kwargs": DotDict(
@@ -6418,12 +6480,12 @@ class MainTable(tk.Canvas):
                 }
             ),
             "sheet_ops": self.PAR.ops,
-            "border_color": self.PAR.ops.table_selected_cells_border_fg,
+            "border_color": self.PAR.ops.table_selected_box_cells_fg,
             "text": text,
             "state": state,
             "width": w,
             "height": h,
-            "show_border": self.PAR.ops.show_selected_cells_border,
+            "show_border": True,
             "bg": bg,
             "fg": fg,
             "align": self.get_cell_align(r, c),
@@ -6462,7 +6524,16 @@ class MainTable(tk.Canvas):
         check_lines: bool = True,
     ) -> None:
         curr_height = self.text_editor.window.winfo_height()
-        if not check_lines or self.get_lines_cell_height(self.text_editor.window.get_num_lines() + 1) > curr_height:
+        if curr_height < self.min_row_height:
+            return
+        if (
+            not check_lines
+            or self.get_lines_cell_height(
+                self.text_editor.window.get_num_lines() + 1,
+                font=self.text_editor.tktext.cget("font"),
+            )
+            > curr_height
+        ):
             new_height = curr_height + self.table_xtra_lines_increment
             space_bot = self.get_space_bot(r)
             if new_height > space_bot:
@@ -6487,24 +6558,30 @@ class MainTable(tk.Canvas):
                         )
                         self.itemconfig(self.dropdown.canvas_id, anchor=anchor, height=win_h)
 
-    def refresh_open_window_positions(self):
+    def refresh_open_window_positions(self, zoom: Literal["in", "out"]):
         if self.text_editor.open:
             r, c = self.text_editor.coords
             self.text_editor.window.config(height=self.row_positions[r + 1] - self.row_positions[r])
+            self.text_editor.tktext.config(font=self.PAR.ops.table_font)
             self.coords(
                 self.text_editor.canvas_id,
                 self.col_positions[c],
                 self.row_positions[r],
             )
         if self.dropdown.open:
+            if zoom == "in":
+                self.dropdown.window.zoom_in()
+            elif zoom == "out":
+                self.dropdown.window.zoom_out()
             r, c = self.dropdown.get_coords()
             if self.text_editor.open:
                 text_editor_h = self.text_editor.window.winfo_height()
                 win_h, anchor = self.get_dropdown_height_anchor(r, c, text_editor_h)
             else:
-                text_editor_h = self.row_positions[r + 1] - self.row_positions[r]
+                text_editor_h = self.row_positions[r + 1] - self.row_positions[r] + 1
                 anchor = self.itemcget(self.dropdown.canvas_id, "anchor")
                 # win_h = 0
+            self.dropdown.window.config(width=self.col_positions[c + 1] - self.col_positions[c] + 1)
             if anchor == "nw":
                 self.coords(
                     self.dropdown.canvas_id,
@@ -6527,7 +6604,6 @@ class MainTable(tk.Canvas):
         if reason == "Escape":
             self.focus_set()
 
-    # c is displayed col
     def close_text_editor(
         self,
         editor_info: tuple | None = None,
@@ -6650,8 +6726,7 @@ class MainTable(tk.Canvas):
     def tab_key(self, event: object = None) -> str:
         if not self.selected:
             return
-        r = self.selected.row
-        c = self.selected.column
+        r, c = self.selected.row, self.selected.column
         r1, c1, r2, c2 = self.selection_boxes[self.selected.fill_iid].coords
         numcols = c2 - c1
         numrows = r2 - r1
@@ -6761,6 +6836,7 @@ class MainTable(tk.Canvas):
             if not self.open_text_editor(event=event, r=r, c=c, dropdown=True):
                 return
         win_h, anchor = self.get_dropdown_height_anchor(r, c)
+        win_w = self.col_positions[c + 1] - self.col_positions[c] + 1
         if anchor == "nw":
             if kwargs["state"] == "normal":
                 ypos = self.row_positions[r] + self.text_editor.window.winfo_height() - 1
@@ -6768,33 +6844,29 @@ class MainTable(tk.Canvas):
                 ypos = self.row_positions[r + 1]
         else:
             ypos = self.row_positions[r]
-        if self.dropdown.window is not None:
-            self.dropdown.window.search_function = kwargs["search_function"]
-            self.dropdown.window.r = r
-            self.dropdown.window.c = c
-            self.dropdown.window.row = -1
-            self.dropdown.window.set_options()
-            self.dropdown.window.values(kwargs["values"])
-            if not self.dropdown.open:
-                self.itemconfig(self.dropdown.canvas_id, state="normal")
+        reset_kwargs = {
+            "r": r,
+            "c": c,
+            "width": win_w,
+            "height": win_h,
+            "font": self.PAR.ops.table_font,
+            "ops": self.PAR.ops,
+            "outline_color": self.get_selected_box_bg_fg(type_="cells")[1],
+            "align": self.get_cell_align(r, c),
+            "values": kwargs["values"],
+        }
+        if self.dropdown.window:
+            self.dropdown.window.reset(**reset_kwargs)
+            self.itemconfig(self.dropdown.canvas_id, state="normal", anchor=anchor)
             self.coords(self.dropdown.canvas_id, self.col_positions[c], ypos)
         else:
             self.dropdown.window = self.PAR.dropdown_class(
                 self.winfo_toplevel(),
-                r,
-                c,
-                width=self.col_positions[c + 1] - self.col_positions[c] + 1,
-                height=win_h,
-                font=self.PAR.ops.table_font,
-                ops=self.PAR.ops,
-                outline_color=self.get_selected_box_bg_fg(type_="cells")[1],
-                outline_thickness=2,
-                values=kwargs["values"],
+                **reset_kwargs,
                 close_dropdown_window=self.close_dropdown_window,
                 search_function=kwargs["search_function"],
                 arrowkey_RIGHT=self.arrowkey_RIGHT,
                 arrowkey_LEFT=self.arrowkey_LEFT,
-                align="w",  # self.get_cell_align(r, c)
             )
             self.dropdown.canvas_id = self.create_window(
                 (self.col_positions[c], ypos),
@@ -7082,7 +7154,12 @@ class MainTable(tk.Canvas):
         self.delete_row_format("all", clear_values=clear_values)
         self.delete_column_format("all", clear_values=clear_values)
 
-    def delete_cell_format(self, datarn: str | int = "all", datacn: int = 0, clear_values: bool = False) -> None:
+    def delete_cell_format(
+        self,
+        datarn: Literal["all"] | int = "all",
+        datacn: int = 0,
+        clear_values: bool = False,
+    ) -> None:
         if isinstance(datarn, str) and datarn.lower() == "all":
             itr = gen_formatted(self.cell_options)
         else:
@@ -7096,7 +7173,7 @@ class MainTable(tk.Canvas):
             if clear_values:
                 self.set_cell_data(*key, get_val(*key), expand_sheet=False)
 
-    def delete_row_format(self, datarn: str | int = "all", clear_values: bool = False) -> None:
+    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:
@@ -7111,7 +7188,7 @@ class MainTable(tk.Canvas):
                 for datacn in range(len(self.data[datarn])):
                     self.set_cell_data(datarn, datacn, get_val(datarn, datacn), expand_sheet=False)
 
-    def delete_column_format(self, datacn: str | int = "all", clear_values: bool = False) -> None:
+    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: