tksheet 7.2.23__py3-none-any.whl → 7.3.1__py3-none-any.whl

tksheet/main_table.py

@@ -15,7 +15,6 @@ from collections.abc import (
     Callable,
     Generator,
     Hashable,
-    Iterator,
     Sequence,
 )
 from functools import (
@@ -59,6 +58,7 @@ from .functions import (
     diff_list,
     down_cell_within_box,
     event_dict,
+    float_to_int,
     gen_formatted,
     get_data_from_clipboard,
     get_new_indexes,
@@ -98,6 +98,9 @@ from .other_classes import (
 from .text_editor import (
     TextEditor,
 )
+from .types import (
+    AnyIter,
+)
 from .vars import (
     USER_OS,
     bind_add_columns,
@@ -257,8 +260,6 @@ class MainTable(tk.Canvas):
         self.rc_insert_row_enabled = False
         self.rc_popup_menus_enabled = False
         self.edit_cell_enabled = False
-        self.new_row_width = 0
-        self.new_header_height = 0
         self.CH = kwargs["column_headers_canvas"]
         self.CH.MT = self
         self.CH.RI = kwargs["row_index_canvas"]
@@ -297,11 +298,6 @@ class MainTable(tk.Canvas):
         self.txt_measure_canvas = tk.Canvas(self)
         self.txt_measure_canvas_text = self.txt_measure_canvas.create_text(0, 0, text="", font=self.PAR.ops.table_font)
 
-        self.max_row_height = float(kwargs["max_row_height"])
-        self.max_index_width = float(kwargs["max_index_width"])
-        self.max_column_width = float(kwargs["max_column_width"])
-        self.max_header_height = float(kwargs["max_header_height"])
-
         self.RI.set_width(self.PAR.ops.default_row_index_width)
         self.set_table_font_help()
         self.set_header_font_help()
@@ -411,7 +407,9 @@ class MainTable(tk.Canvas):
             ("<Control-MouseWheel>", self.ctrl_mousewheel),
             ("<Control-plus>", self.zoom_in),
             ("<Control-equal>", self.zoom_in),
+            ("<Meta-Command-equal>", self.zoom_in),
             ("<Control-minus>", self.zoom_out),
+            ("<Meta-Command-minus>", self.zoom_out),
         )
         mt_ri_canvas_linux_bindings = {
             ("<Button-4>", self.mousewheel),
@@ -1850,14 +1848,43 @@ class MainTable(tk.Canvas):
             if redraw:
                 self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
             if run_binding_func:
-                if self.select_all_binding_func:
-                    self.select_all_binding_func(
-                        self.get_select_event(being_drawn_item=self.being_drawn_item),
-                    )
                 event_data = self.get_select_event(self.being_drawn_item)
+                try_binding(self.select_all_binding_func, event_data)
                 self.PAR.emit_event("<<SheetSelect>>", data=event_data)
                 self.PAR.emit_event("<<SelectAll>>", data=event_data)
 
+    def select_columns(self, event: object) -> None:
+        if not self.selected:
+            return
+        r1, c1, r2, c2 = self.selection_boxes[self.selected.fill_iid].coords
+        r, c = self.selected.row, self.selected.column
+        self.set_currently_selected(
+            r=r,
+            c=c,
+            item=self.CH.select_col(range(c1, c2), redraw=True),
+        )
+
+    def select_rows(self, event: object) -> None:
+        if not self.selected:
+            return
+        r1, c1, r2, c2 = self.selection_boxes[self.selected.fill_iid].coords
+        r, c = self.selected.row, self.selected.column
+        self.set_currently_selected(
+            r=r,
+            c=c,
+            item=self.RI.select_row(range(r1, r2), redraw=True),
+        )
+
+    def select_row_start(self, event: object) -> None:
+        if self.selected:
+            self.select_cell(self.selected.row, 0)
+            self.see(self.selected.row, 0)
+
+    def select_a1(self, event: object) -> None:
+        if len(self.row_positions) > 1 and len(self.col_positions) > 1:
+            self.select_cell(0, 0)
+            self.see(0, 0)
+
     def select_cell(
         self,
         r: int,
@@ -1940,7 +1967,9 @@ class MainTable(tk.Canvas):
     ) -> None:
         if not self.selected:
             return
+        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():
                 self.hide_selection_box(item)
         elif r in ("allrows", "allcols"):
@@ -1950,6 +1979,8 @@ class MainTable(tk.Canvas):
                 cells=False,
             ):
                 self.hide_selection_box(item)
+                if item == curr_box:
+                    self.hide_dropdown_editor_all_canvases()
         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
@@ -1957,6 +1988,8 @@ class MainTable(tk.Canvas):
                     resel = self.selected.fill_iid == item
                     to_sel = self.selected.row
                     self.hide_selection_box(item)
+                    if item == curr_box:
+                        self.hide_dropdown_editor_all_canvases()
                     if r2 - r1 != 1:
                         if r == r1:
                             self.create_selection_box(
@@ -2000,6 +2033,8 @@ class MainTable(tk.Canvas):
                     resel = self.selected.fill_iid == item
                     to_sel = self.selected.column
                     self.hide_selection_box(item)
+                    if item == curr_box:
+                        self.hide_dropdown_editor_all_canvases()
                     if c2 - c1 != 1:
                         if c == c1:
                             self.create_selection_box(
@@ -2043,6 +2078,8 @@ class MainTable(tk.Canvas):
                 r1, c1, r2, c2 = box.coords
                 if r >= r1 and c >= c1 and r < r2 and c < c2:
                     self.hide_selection_box(item)
+                    if item == curr_box:
+                        self.hide_text_editor_and_dropdown(redraw=False)
         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)
@@ -2052,12 +2089,15 @@ class MainTable(tk.Canvas):
 
     def deselect_any(
         self,
-        rows: Iterator[int] | int | None = None,
-        columns: Iterator[int] | int | None = None,
+        rows: AnyIter[int] | int | None = None,
+        columns: AnyIter[int] | int | None = None,
         redraw: bool = True,
     ) -> None:
+        if not self.selected:
+            return
         rows = int_x_iter(rows)
         columns = int_x_iter(columns)
+        curr_box = self.selected.fill_iid
         if is_iterable(rows) and is_iterable(columns):
             rows = tuple(consecutive_ranges(sorted(rows)))
             columns = tuple(consecutive_ranges(sorted(columns)))
@@ -2072,6 +2112,8 @@ class MainTable(tk.Canvas):
                             (cols_end >= c1 and cols_end <= c2) or (cols_st >= c1 and cols_st < c2)
                         ):
                             hidden = self.hide_selection_box(item)
+                            if item == curr_box:
+                                self.hide_dropdown_editor_all_canvases()
                             break
         elif is_iterable(rows):
             rows = tuple(consecutive_ranges(sorted(rows)))
@@ -2080,6 +2122,8 @@ class MainTable(tk.Canvas):
                 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)
+                        if item == curr_box:
+                            self.hide_dropdown_editor_all_canvases()
                         break
         elif is_iterable(columns):
             columns = tuple(consecutive_ranges(sorted(columns)))
@@ -2088,6 +2132,8 @@ class MainTable(tk.Canvas):
                 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)
+                        if item == curr_box:
+                            self.hide_dropdown_editor_all_canvases()
                         break
         else:
             self.deselect()
@@ -2678,7 +2724,7 @@ class MainTable(tk.Canvas):
             self._enable_binding(bindings.lower())
         self.create_rc_menus()
 
-    def disable_bindings(self, bindings):
+    def disable_bindings(self, bindings: object) -> None:
         if not bindings:
             self._disable_binding("all")
         elif isinstance(bindings, (list, tuple)):
@@ -2692,21 +2738,33 @@ class MainTable(tk.Canvas):
             self._disable_binding(bindings)
         self.create_rc_menus()
 
-    def _enable_binding(self, binding):
+    def _enable_binding(self, binding: str) -> None:
         if binding == "enable_all":
             binding = "all"
-        if binding in ("all", "single", "single_selection_mode", "single_select"):
-            self.single_selection_enabled = True
-            self.toggle_selection_enabled = False
-        elif binding in ("toggle", "toggle_selection_mode", "toggle_select"):
-            self.toggle_selection_enabled = True
-            self.single_selection_enabled = False
+        if binding in (
+            "all",
+            "single",
+            "single_selection_mode",
+            "single_select",
+            "toggle",
+            "toggle_selection_mode",
+            "toggle_select",
+        ):
+            self._tksheet_bind("row_start_bindings", self.select_row_start)
+            self._tksheet_bind("table_start_bindings", self.select_a1)
+            if binding in ("all", "single", "single_selection_mode", "single_select"):
+                self.single_selection_enabled = True
+                self.toggle_selection_enabled = False
+            elif binding in ("toggle", "toggle_selection_mode", "toggle_select"):
+                self.toggle_selection_enabled = True
+                self.single_selection_enabled = False
         if binding in ("all", "drag_select"):
             self.drag_selection_enabled = True
         if binding in ("all", "column_width_resize"):
             self.CH.width_resizing_enabled = True
         if binding in ("all", "column_select"):
             self.CH.col_selection_enabled = True
+            self._tksheet_bind("select_columns_bindings", self.select_columns)
         if binding in ("all", "column_height_resize"):
             self.CH.height_resizing_enabled = True
             self.TL.rh_state()
@@ -2723,6 +2781,7 @@ class MainTable(tk.Canvas):
             self.TL.rw_state()
         if binding in ("all", "row_select"):
             self.RI.row_selection_enabled = True
+            self._tksheet_bind("select_rows_bindings", self.select_rows)
         if binding in ("all", "row_drag_and_drop", "move_rows"):
             self.RI.drag_and_drop_enabled = True
         if binding in ("all", "select_all"):
@@ -2808,21 +2867,29 @@ class MainTable(tk.Canvas):
             for binding in self.PAR.ops[bindings_key]:
                 widget.bind(binding, func)
 
-    def _disable_binding(self, binding):
+    def _disable_binding(self, binding: str) -> None:
         if binding == "disable_all":
             binding = "all"
-        if binding in ("all", "single", "single_selection_mode", "single_select"):
+        if binding in (
+            "all",
+            "single",
+            "single_selection_mode",
+            "single_select",
+            "toggle",
+            "toggle_selection_mode",
+            "toggle_select",
+        ):
+            self._tksheet_unbind("row_start_bindings")
+            self._tksheet_unbind("table_start_bindings")
             self.single_selection_enabled = False
             self.toggle_selection_enabled = False
-        elif binding in ("toggle", "toggle_selection_mode", "toggle_select"):
-            self.toggle_selection_enabled = False
-            self.single_selection_enabled = False
         if binding in ("all", "drag_select"):
             self.drag_selection_enabled = False
         if binding in ("all", "column_width_resize"):
             self.CH.width_resizing_enabled = False
         if binding in ("all", "column_select"):
             self.CH.col_selection_enabled = False
+            self._tksheet_unbind("select_columns_bindings")
         if binding in ("all", "column_height_resize"):
             self.CH.height_resizing_enabled = False
             self.TL.rh_state("hidden")
@@ -2839,6 +2906,7 @@ class MainTable(tk.Canvas):
             self.TL.rw_state("hidden")
         if binding in ("all", "row_select"):
             self.RI.row_selection_enabled = False
+            self._tksheet_unbind("select_rows_bindings")
         if binding in ("all", "row_drag_and_drop", "move_rows"):
             self.RI.drag_and_drop_enabled = False
         if binding in bind_del_columns:
@@ -3210,20 +3278,6 @@ class MainTable(tk.Canvas):
                 run_binding=False,
             )
         self.hide_selection_box(to_hide)
-        if self.RI.width_resizing_enabled and self.RI.rsz_w is not None and self.RI.currently_resizing_width:
-            self.delete_resize_lines()
-            self.RI.delete_resize_lines()
-            self.RI.currently_resizing_width = False
-            self.RI.set_width(self.new_row_width, set_TL=True)
-            self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
-            self.b1_pressed_loc = None
-        elif self.CH.height_resizing_enabled and self.CH.rsz_h is not None and self.CH.currently_resizing_height:
-            self.delete_resize_lines()
-            self.CH.delete_resize_lines()
-            self.CH.currently_resizing_height = False
-            self.CH.set_height(self.new_header_height, set_TL=True)
-            self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
-            self.b1_pressed_loc = None
         self.RI.rsz_w = None
         self.CH.rsz_h = None
         if self.b1_pressed_loc is not None:
@@ -3546,7 +3600,7 @@ class MainTable(tk.Canvas):
             c_pc=c_pc,
         )
 
-    def get_txt_w(self, txt, font=None):
+    def get_txt_w(self, txt: str, font: None | FontTuple = None) -> int:
         self.txt_measure_canvas.itemconfig(
             self.txt_measure_canvas_text,
             text=txt,
@@ -3555,7 +3609,7 @@ class MainTable(tk.Canvas):
         b = self.txt_measure_canvas.bbox(self.txt_measure_canvas_text)
         return b[2] - b[0]
 
-    def get_txt_h(self, txt, font=None):
+    def get_txt_h(self, txt: str, font: None | FontTuple = None) -> int:
         self.txt_measure_canvas.itemconfig(
             self.txt_measure_canvas_text,
             text=txt,
@@ -3564,7 +3618,7 @@ class MainTable(tk.Canvas):
         b = self.txt_measure_canvas.bbox(self.txt_measure_canvas_text)
         return b[3] - b[1]
 
-    def get_txt_dimensions(self, txt, font=None):
+    def get_txt_dimensions(self, txt: str, font: None | FontTuple = None) -> int:
         self.txt_measure_canvas.itemconfig(
             self.txt_measure_canvas_text,
             text=txt,
@@ -3573,7 +3627,7 @@ class MainTable(tk.Canvas):
         b = self.txt_measure_canvas.bbox(self.txt_measure_canvas_text)
         return b[2] - b[0], b[3] - b[1]
 
-    def get_lines_cell_height(self, n, font=None):
+    def get_lines_cell_height(self, n: int, font: None | FontTuple = None) -> int:
         return (
             self.get_txt_h(
                 txt="\n".join("|" for _ in range(n)) if n > 1 else "|",
@@ -3582,15 +3636,17 @@ class MainTable(tk.Canvas):
             + 5
         )
 
-    def set_min_column_width(self):
-        self.min_column_width = 1
-        if self.min_column_width > self.max_column_width:
-            self.max_column_width = self.min_column_width + 20
+    def set_min_column_width(self, width: int) -> None:
+        if width:
+            self.PAR.ops.min_column_width = width
+
+        if self.PAR.ops.min_column_width > self.PAR.ops.max_column_width:
+            self.PAR.ops.max_column_width = self.PAR.ops.min_column_width + 20
         if (
             isinstance(self.PAR.ops.auto_resize_columns, (int, float))
-            and self.PAR.ops.auto_resize_columns < self.min_column_width
+            and self.PAR.ops.auto_resize_columns < self.PAR.ops.min_column_width
         ):
-            self.PAR.ops.auto_resize_columns = self.min_column_width
+            self.PAR.ops.auto_resize_columns = self.PAR.ops.min_column_width
 
     def get_default_row_height(self) -> int:
         if isinstance(self.PAR.ops.default_row_height, str):
@@ -3641,7 +3697,6 @@ class MainTable(tk.Canvas):
         self.table_xtra_lines_increment = int(self.table_txt_height)
         if self.min_row_height < 12:
             self.min_row_height = 12
-        self.set_min_column_width()
 
     def set_header_font(self, newfont: tuple | None = None) -> tuple[str, int, str]:
         if newfont:
@@ -3672,7 +3727,6 @@ class MainTable(tk.Canvas):
             and self.PAR.ops.default_header_height < self.min_header_height
         ):
             self.PAR.ops.default_header_height = int(self.min_header_height)
-        self.set_min_column_width()
         self.CH.set_height(self.get_default_header_height(), set_TL=True)
 
     def set_index_font(self, newfont: tuple | None = None) -> tuple[str, int, str]:
@@ -3742,15 +3796,15 @@ class MainTable(tk.Canvas):
             w = b[2] - b[0] + 7
             h = b[3] - b[1] + 5
         else:
-            w = self.min_column_width
+            w = self.PAR.ops.min_column_width
             h = self.min_row_height
         if self.get_cell_kwargs(datarn, datacn, key="dropdown") or self.get_cell_kwargs(datarn, datacn, key="checkbox"):
             return w + self.table_txt_height, h
         return w, h
 
     def set_cell_size_to_text(self, r, c, only_if_too_small=False, redraw: bool = True, run_binding=False):
-        min_column_width = int(self.min_column_width)
-        min_rh = int(self.min_row_height)
+        min_column_width = self.PAR.ops.min_column_width
+        min_rh = self.min_row_height
         w = min_column_width
         h = min_rh
         datacn = self.datacn(c)
@@ -3759,13 +3813,13 @@ class MainTable(tk.Canvas):
         if tw > w:
             w = tw
         if h < min_rh:
-            h = int(min_rh)
-        elif h > self.max_row_height:
-            h = int(self.max_row_height)
+            h = min_rh
+        elif h > self.PAR.ops.max_row_height:
+            h = int(self.PAR.ops.max_row_height)
         if w < min_column_width:
-            w = int(min_column_width)
-        elif w > self.max_column_width:
-            w = int(self.max_column_width)
+            w = min_column_width
+        elif w > self.PAR.ops.max_column_width:
+            w = int(self.PAR.ops.max_column_width)
         cell_needs_resize_w = False
         cell_needs_resize_h = False
         if only_if_too_small:
@@ -3825,8 +3879,10 @@ class MainTable(tk.Canvas):
         width: int | None = None,
         slim: bool = False,
     ) -> tuple[list[float], list[float]]:
-        min_column_width = int(self.min_column_width)
-        min_rh = int(self.min_row_height)
+        min_column_width = self.PAR.ops.min_column_width
+        max_column_width = float_to_int(self.PAR.ops.max_column_width)
+        max_row_height = float_to_int(self.PAR.ops.max_row_height)
+        min_rh = self.min_row_height
         h = min_rh
         rhs = defaultdict(lambda: int(min_rh))
         cws = []
@@ -3849,9 +3905,9 @@ class MainTable(tk.Canvas):
             for datarn in iterrows:
                 w_, h = self.RI.get_cell_dimensions(datarn)
                 if h < min_rh:
-                    h = int(min_rh)
-                elif h > self.max_row_height:
-                    h = int(self.max_row_height)
+                    h = min_rh
+                elif h > max_row_height:
+                    h = max_row_height
                 if h > rhs[datarn]:
                     rhs[datarn] = h
         added_w_space = 1 if slim else 7
@@ -3883,22 +3939,22 @@ class MainTable(tk.Canvas):
                 if tw > w:
                     w = tw
                 if h < min_rh:
-                    h = int(min_rh)
-                elif h > self.max_row_height:
-                    h = int(self.max_row_height)
+                    h = min_rh
+                elif h > max_row_height:
+                    h = max_row_height
                 if h > rhs[datarn]:
                     rhs[datarn] = h
             if w < min_column_width:
-                w = int(min_column_width)
-            elif w > self.max_column_width:
-                w = int(self.max_column_width)
+                w = min_column_width
+            elif w > max_column_width:
+                w = max_column_width
             cws.append(w)
         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
 
-    def set_col_positions(self, itr: Iterator[float]) -> None:
+    def set_col_positions(self, itr: AnyIter[float]) -> None:
         self.col_positions = list(accumulate(chain([0], itr)))
 
     def reset_col_positions(self, ncols: int | None = None):
@@ -3910,7 +3966,7 @@ class MainTable(tk.Canvas):
         else:
             self.set_col_positions(itr=repeat(colpos, len(self.displayed_columns)))
 
-    def set_row_positions(self, itr: Iterator[float]) -> None:
+    def set_row_positions(self, itr: AnyIter[float]) -> None:
         self.row_positions = list(accumulate(chain([0], itr)))
 
     def reset_row_positions(self, nrows: int | None = None):
@@ -3944,7 +4000,7 @@ class MainTable(tk.Canvas):
             del self.row_positions[idx]
             self.row_positions[idx:] = [e - w for e in islice(self.row_positions, idx, len(self.row_positions))]
 
-    def del_col_positions(self, idxs: Iterator[int] | None = None):
+    def del_col_positions(self, idxs: AnyIter[int] | None = None):
         if idxs is None:
             del self.col_positions[-1]
         else:
@@ -3952,7 +4008,7 @@ class MainTable(tk.Canvas):
                 idxs = set(idxs)
             self.set_col_positions(itr=(w for i, w in enumerate(self.gen_column_widths()) if i not in idxs))
 
-    def del_row_positions(self, idxs: Iterator[int] | None = None):
+    def del_row_positions(self, idxs: AnyIter[int] | None = None):
         if idxs is None:
             del self.row_positions[-1]
         else:
@@ -4952,7 +5008,7 @@ class MainTable(tk.Canvas):
 
     def display_rows(
         self,
-        rows: int | Iterator | None = None,
+        rows: int | AnyIter | None = None,
         all_rows_displayed: bool | None = None,
         reset_row_positions: bool = True,
         deselect_all: bool = True,
@@ -4981,7 +5037,7 @@ class MainTable(tk.Canvas):
 
     def display_columns(
         self,
-        columns: int | Iterator | None = None,
+        columns: int | AnyIter | None = None,
         all_columns_displayed: bool | None = None,
         reset_col_positions: bool = True,
         deselect_all: bool = True,
@@ -5475,8 +5531,8 @@ class MainTable(tk.Canvas):
         resized_rows = False
         if self.PAR.ops.auto_resize_columns and self.allow_auto_resize_columns and col_pos_exists:
             max_w = can_width - self.PAR.ops.empty_horizontal
-            if self.PAR.ops.auto_resize_columns < self.min_column_width:
-                min_column_width = self.column_width
+            if self.PAR.ops.auto_resize_columns < self.PAR.ops.min_column_width:
+                min_column_width = self.PAR.ops.min_column_width
             else:
                 min_column_width = self.PAR.ops.auto_resize_columns
             if (len(self.col_positions) - 1) * min_column_width < max_w:
@@ -5956,7 +6012,7 @@ class MainTable(tk.Canvas):
         rows: bool = True,
         columns: bool = True,
         reverse: bool = False,
-    ) -> Generator[int]:
+    ) -> tuple[tuple[int, SelectionBox]]:
         """
         Most recent selection box should be last
         """
@@ -6409,31 +6465,55 @@ class MainTable(tk.Canvas):
     def recreate_all_selection_boxes(self) -> None:
         if not self.selected:
             return
+        modified = False
         for item, box in self.get_selection_items():
             r1, c1, r2, c2 = box.coords
+            if not modified:
+                modified = (
+                    r1 >= len(self.row_positions) - 1
+                    or c1 >= len(self.col_positions) - 1
+                    or r2 > len(self.row_positions) - 1
+                    or c2 > len(self.col_positions) - 1
+                )
             if r1 >= len(self.row_positions) - 1:
                 if len(self.row_positions) > 1:
                     r1 = len(self.row_positions) - 2
                 else:
-                    r1 = len(self.row_positions) - 1
+                    r1 = 0
             if c1 >= len(self.col_positions) - 1:
                 if len(self.col_positions) > 1:
                     c1 = len(self.col_positions) - 2
                 else:
-                    c1 = len(self.col_positions) - 1
+                    c1 = 0
             if r2 > len(self.row_positions) - 1:
                 r2 = len(self.row_positions) - 1
             if c2 > len(self.col_positions) - 1:
                 c2 = len(self.col_positions) - 1
-            self.recreate_selection_box(r1, c1, r2, c2, item)
+            self.recreate_selection_box(r1, c1, r2, c2, item, run_binding=False)
+
         if self.selected:
             r = self.selected.row
             c = self.selected.column
             if r < len(self.row_positions) - 1 and c < len(self.col_positions) - 1:
-                self.set_currently_selected(r, c, item=self.selected.fill_iid)
+                self.set_currently_selected(
+                    r,
+                    c,
+                    item=self.selected.fill_iid,
+                    run_binding=False,
+                )
             else:
                 box = self.selection_boxes[self.selected.fill_iid]
-                self.set_currently_selected(box.coords.from_r, box.coords.from_c, item=box.fill_iid)
+                self.set_currently_selected(
+                    box.coords.from_r,
+                    box.coords.from_c,
+                    item=box.fill_iid,
+                    run_binding=False,
+                )
+        if modified:
+            self.PAR.emit_event(
+                "<<SheetSelect>>",
+                data=self.get_select_event(self.being_drawn_item),
+            )
 
     def get_redraw_selections(self, startr: int, endr: int, startc: int, endc: int) -> dict:
         d = defaultdict(set)
@@ -6891,7 +6971,7 @@ class MainTable(tk.Canvas):
             name="end_edit_table",
             sheet=self.PAR.name,
             widget=self,
-            cells_table={(datarn, datacn): text_editor_value},
+            cells_table={(datarn, datacn): self.get_cell_data(datarn, datacn)},
             key=event.keysym,
             value=text_editor_value,
             loc=Loc(r, c),