tksheet 7.1.7__py3-none-any.whl → 7.1.9__py3-none-any.whl

tksheet/main_table.py

@@ -26,7 +26,6 @@ from itertools import (
     chain,
     cycle,
     islice,
-    product,
     repeat,
 )
 from math import (
@@ -56,7 +55,6 @@ from .functions import (
     ev_stack_dict,
     event_dict,
     gen_formatted,
-    rounded_box_coords,
     get_new_indexes,
     get_seq_without_gaps_at_index,
     index_exists,
@@ -67,10 +65,11 @@ from .functions import (
     len_to_idx,
     mod_event_val,
     mod_span,
+    mod_span_widget,
     move_elements_by_mapping,
     pickle_obj,
+    rounded_box_coords,
     span_idxs_post_move,
-    mod_span_widget,
     try_binding,
     unpickle_obj,
 )
@@ -82,6 +81,7 @@ from .other_classes import (
     DropdownStorage,
     EventDataDict,
     FontTuple,
+    Loc,
     Selected,
     SelectionBox,
     TextEditorStorage,
@@ -94,6 +94,7 @@ from .vars import (
     ctrl_key,
     rc_binding,
     symbols_set,
+    text_editor_to_unbind,
     val_modifying_options,
 )
 
@@ -675,7 +676,7 @@ class MainTable(tk.Canvas):
         if lastbox_numrows > new_data_numrows and not lastbox_numrows % new_data_numrows:
             nd = []
             for _ in range(int(lastbox_numrows / new_data_numrows)):
-                nd.extend([r.copy() for r in data])
+                nd.extend(r.copy() for r in data)
             data.extend(nd)
             new_data_numrows *= int(lastbox_numrows / new_data_numrows)
 
@@ -971,14 +972,14 @@ class MainTable(tk.Canvas):
                         run_binding=True,
                     )
         if move_data:
-            self.data[:] = [
-                move_elements_by_mapping(
-                    r,
-                    data_new_idxs,
-                    data_old_idxs,
-                )
-                for r in self.data
-            ]
+            self.data = list(
+                map(
+                    move_elements_by_mapping,
+                    self.data,
+                    repeat(data_new_idxs),
+                    repeat(data_old_idxs),
+                ),
+            )
             maxidx = len_to_idx(totalcols)
             self.CH.fix_header(maxidx)
             if isinstance(self._headers, list) and self._headers:
@@ -1129,7 +1130,11 @@ class MainTable(tk.Canvas):
             )
         else:
             disp_new_idxs = {}
-        totalrows = self.fix_data_len(move_to)
+        self.fix_data_len(move_to)
+        totalrows = max(
+            self.total_data_rows(),
+            len(self.row_positions) - 1,
+        )
         if self.all_rows_displayed or data_indexes:
             data_new_idxs = get_new_indexes(seqlen=totalrows, move_to=move_to, to_move=to_move)
         elif not self.all_rows_displayed and not data_indexes:
@@ -1156,7 +1161,12 @@ class MainTable(tk.Canvas):
     ) -> tuple[dict[int, int], dict[int, int], EventDataDict]:
         self.saved_row_heights = {}
         if not isinstance(totalrows, int):
-            totalrows = self.fix_data_len(max(data_new_idxs.values(), default=0))
+            totalrows = max(
+                self.total_data_rows(),
+                len(self.row_positions) - 1,
+                max(data_new_idxs.values(), default=0),
+            )
+            totalrows = self.fix_data_len(totalrows)
         if event_data is None:
             event_data = event_dict(
                 name="move_rows",
@@ -1195,7 +1205,7 @@ class MainTable(tk.Canvas):
                         run_binding=True,
                     )
         if move_data:
-            self.data[:] = move_elements_by_mapping(
+            self.data = move_elements_by_mapping(
                 self.data,
                 data_new_idxs,
                 data_old_idxs,
@@ -1443,9 +1453,7 @@ class MainTable(tk.Canvas):
             saved_cells = True
 
         if modification["moved"]["columns"]:
-            totalcols = self.equalize_data_row_lengths()
-            if totalcols < (mx_k := max(modification["moved"]["columns"]["data"].values())):
-                totalcols = mx_k
+            totalcols = max(self.equalize_data_row_lengths(), max(modification["moved"]["columns"]["data"].values()))
             data_new_idxs, disp_new_idxs, event_data = self.move_columns_adjust_options_dict(
                 data_new_idxs=dict(
                     zip(
@@ -1470,9 +1478,7 @@ class MainTable(tk.Canvas):
             self.restore_options_named_spans(modification)
 
         if modification["moved"]["rows"]:
-            totalrows = self.total_data_rows()
-            if totalrows < (mx_k := max(modification["moved"]["rows"]["data"].values())):
-                totalrows = mx_k
+            totalrows = max(self.total_data_rows(), max(modification["moved"]["rows"]["data"].values()))
             data_new_idxs, disp_new_idxs, event_data = self.move_rows_adjust_options_dict(
                 data_new_idxs=dict(
                     zip(
@@ -2744,8 +2750,7 @@ class MainTable(tk.Canvas):
 
     def mouse_motion(self, event: object):
         self.reset_mouse_motion_creations()
-        if self.extra_motion_func:
-            self.extra_motion_func(event)
+        try_binding(self.extra_motion_func, event)
 
     def not_currently_resizing(self) -> bool:
         return all(v is None for v in (self.RI.rsz_h, self.RI.rsz_w, self.CH.rsz_h, self.CH.rsz_w))
@@ -2758,12 +2763,15 @@ class MainTable(tk.Canvas):
             r = self.identify_row(y=event.y)
             c = self.identify_col(x=event.x)
             if r < len(self.row_positions) - 1 and c < len(self.col_positions) - 1:
-                if self.col_selected(c) and self.rc_popup_menus_enabled:
-                    popup_menu = self.CH.ch_rc_popup_menu
-                elif self.row_selected(r) and self.rc_popup_menus_enabled:
-                    popup_menu = self.RI.ri_rc_popup_menu
-                elif self.cell_selected(r, c) and self.rc_popup_menus_enabled:
-                    popup_menu = self.rc_popup_menu
+                if self.col_selected(c):
+                    if self.rc_popup_menus_enabled:
+                        popup_menu = self.CH.ch_rc_popup_menu
+                elif self.row_selected(r):
+                    if self.rc_popup_menus_enabled:
+                        popup_menu = self.RI.ri_rc_popup_menu
+                elif self.cell_selected(r, c):
+                    if self.rc_popup_menus_enabled:
+                        popup_menu = self.rc_popup_menu
                 else:
                     if self.rc_select_enabled:
                         if self.single_selection_enabled:
@@ -2773,9 +2781,9 @@ class MainTable(tk.Canvas):
                     if self.rc_popup_menus_enabled:
                         popup_menu = self.rc_popup_menu
             else:
+                self.deselect("all")
                 popup_menu = self.empty_rc_popup_menu
-        if self.extra_rc_func:
-            self.extra_rc_func(event)
+        try_binding(self.extra_rc_func, event)
         if popup_menu is not None:
             popup_menu.tk_popup(event.x_root, event.y_root)
 
@@ -2799,8 +2807,7 @@ class MainTable(tk.Canvas):
             if r < len(self.row_positions) - 1 and c < len(self.col_positions) - 1:
                 self.toggle_select_cell(r, c, redraw=True)
         self.b1_pressed_loc = (r, c)
-        if self.extra_b1_press_func:
-            self.extra_b1_press_func(event)
+        try_binding(self.extra_b1_press_func, event)
 
     def create_resize_line(self, x1, y1, x2, y2, width, fill, tag):
         if self.hidd_resize_lines:
@@ -2968,8 +2975,7 @@ class MainTable(tk.Canvas):
                 need_redraw = True
             if need_redraw:
                 self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True, redraw_table=True)
-        if self.extra_b1_motion_func:
-            self.extra_b1_motion_func(event)
+        try_binding(self.extra_b1_motion_func, event)
 
     def ctrl_b1_motion(self, event: object):
         if self.ctrl_select_enabled and self.drag_selection_enabled and self.not_currently_resizing():
@@ -3081,8 +3087,7 @@ class MainTable(tk.Canvas):
                 self.mouseclick_outside_editor_or_dropdown_all_canvases()
         self.b1_pressed_loc = None
         self.closed_dropdown = None
-        if self.extra_b1_release_func:
-            self.extra_b1_release_func(event)
+        try_binding(self.extra_b1_release_func, event)
 
     def double_b1(self, event=None):
         self.mouseclick_outside_editor_or_dropdown_all_canvases()
@@ -3106,8 +3111,7 @@ class MainTable(tk.Canvas):
                 self.toggle_select_cell(r, c, redraw=True)
                 if self.edit_cell_enabled:
                     self.open_cell(event)
-        if self.extra_double_b1_func:
-            self.extra_double_b1_func(event)
+        try_binding(self.extra_double_b1_func, event)
 
     def identify_row(self, event=None, y=None, allow_end=True):
         if event is None:
@@ -3213,39 +3217,30 @@ class MainTable(tk.Canvas):
             #     continue
 
     def set_xviews(self, *args, move_synced: bool = True, redraw: bool = True) -> None:
+        self.main_table_redraw_grid_and_text(setting_views=True)
+        self.update_idletasks()
         self.xview(*args)
         if self.show_header:
             self.CH.xview(*args)
         if move_synced:
             self.x_move_synced_scrolls(*args)
         self.fix_views()
-        if redraw:
-            self.main_table_redraw_grid_and_text(redraw_header=True if self.show_header else False)
+        self.PAR.set_refresh_timer(redraw)
 
     def set_yviews(self, *args, move_synced: bool = True, redraw: bool = True) -> None:
+        self.main_table_redraw_grid_and_text(setting_views=True)
+        self.update_idletasks()
         self.yview(*args)
         if self.show_index:
             self.RI.yview(*args)
         if move_synced:
             self.y_move_synced_scrolls(*args)
         self.fix_views()
-        if redraw:
-            self.main_table_redraw_grid_and_text(redraw_row_index=True if self.show_index else False)
+        self.PAR.set_refresh_timer(redraw)
 
     def set_view(self, x_args: list[str, float], y_args: list[str, float]) -> None:
-        self.xview(*x_args)
-        if self.show_header:
-            self.CH.xview(*x_args)
-        self.yview(*y_args)
-        if self.show_index:
-            self.RI.yview(*y_args)
-        self.x_move_synced_scrolls(*x_args)
-        self.y_move_synced_scrolls(*y_args)
-        self.fix_views()
-        self.main_table_redraw_grid_and_text(
-            redraw_row_index=True if self.show_index else False,
-            redraw_header=True if self.show_header else False,
-        )
+        self.set_xviews(*x_args)
+        self.set_yviews(*y_args)
 
     def mousewheel(self, event: object) -> None:
         if event.delta < 0 or event.num == 5:
@@ -3337,7 +3332,9 @@ class MainTable(tk.Canvas):
                                 else (
                                     default_row_height
                                     if h == old_default_row_height
-                                    else self.min_row_height if h < self.min_row_height else h
+                                    else self.min_row_height
+                                    if h < self.min_row_height
+                                    else h
                                 )
                             )
                             for h in self.gen_row_heights()
@@ -4282,7 +4279,7 @@ class MainTable(tk.Canvas):
         return event_data
 
     def rc_add_columns(self, event: object = None):
-        rowlen = self.equalize_data_row_lengths(include_header=False)
+        rowlen = self.equalize_data_row_lengths()
         selcols = sorted(self.get_selected_cols())
         if (
             selcols
@@ -4868,24 +4865,15 @@ class MainTable(tk.Canvas):
                 return self._row_index
 
     def total_data_cols(self, include_header: bool = True) -> int:
-        h_total = 0
-        d_total = 0
-        if include_header:
-            if isinstance(self._headers, (list, tuple)):
-                h_total = len(self._headers)
-        # map() for some reason is 15% faster than max(key=len)
-        # using python 3.11 windows 11
+        h_total = len(self._headers) if include_header and isinstance(self._headers, (list, tuple)) else 0
+        # map() for some reason is 15% faster than max(key=len) using python 3.11 windows 11
         d_total = max(map(len, self.data), default=0)
-        return h_total if h_total > d_total else d_total
+        return max(h_total, d_total)
 
     def total_data_rows(self, include_index: bool = True) -> int:
-        i_total = 0
-        d_total = 0
-        if include_index:
-            if isinstance(self._row_index, (list, tuple)):
-                i_total = len(self._row_index)
+        i_total = len(self._row_index) if include_index and isinstance(self._row_index, (list, tuple)) else 0
         d_total = len(self.data)
-        return i_total if i_total > d_total else d_total
+        return max(i_total, d_total)
 
     def data_dimensions(self, total_rows: int | None = None, total_columns: int | None = None):
         if total_rows is None and total_columns is None:
@@ -4893,7 +4881,7 @@ class MainTable(tk.Canvas):
         if total_rows is not None:
             if len(self.data) < total_rows:
                 ncols = self.total_data_cols() if total_columns is None else total_columns
-                self.data.extend([self.get_empty_row_seq(r, ncols) for r in range(total_rows - len(self.data))])
+                self.data.extend(self.get_empty_row_seq(r, ncols) for r in range(total_rows - len(self.data)))
             else:
                 self.data[total_rows:] = []
         if total_columns is not None:
@@ -4905,7 +4893,7 @@ class MainTable(tk.Canvas):
 
     def equalize_data_row_lengths(
         self,
-        include_header: bool = False,
+        include_header: bool = True,
         total_data_cols: int | None = None,
         at_least_cols: int | None = None,
     ) -> int:
@@ -4913,6 +4901,7 @@ class MainTable(tk.Canvas):
             total_data_cols = self.total_data_cols(include_header=include_header)
         if isinstance(at_least_cols, int) and at_least_cols > total_data_cols:
             total_data_cols = at_least_cols
+        total_data_cols = max(total_data_cols, len(self.col_positions) - 1)
         if include_header and total_data_cols > len(self._headers):
             self.CH.fix_header(total_data_cols)
         for rn, r in enumerate(self.data):
@@ -5193,6 +5182,7 @@ class MainTable(tk.Canvas):
         redraw_header: bool = False,
         redraw_row_index: bool = False,
         redraw_table: bool = True,
+        setting_views: bool = False,
     ) -> bool:
         try:
             can_width = self.winfo_width()
@@ -5286,6 +5276,8 @@ class MainTable(tk.Canvas):
         if scrollregion != self.scrollregion:
             self.configure(scrollregion=scrollregion)
             self.scrollregion = scrollregion
+        if setting_views:
+            return False
         scrollpos_bot = self.canvasy(can_height)
         end_row = bisect_right(self.row_positions, scrollpos_bot)
         if not scrollpos_bot >= self.row_positions[-1]:
@@ -5765,8 +5757,8 @@ class MainTable(tk.Canvas):
         fill, outline = self.get_selected_box_bg_fg(type_=type_)
         x1 = self.col_positions[c] + 1
         y1 = self.row_positions[r] + 1
-        x2 = self.col_positions[c + 1] if index_exists(self.col_positions, c + 1) else self.col_positions[c]
-        y2 = self.row_positions[r + 1] if index_exists(self.row_positions, r + 1) else self.row_positions[r]
+        x2 = self.col_positions[c + 1] if index_exists(self.col_positions, c + 1) else self.col_positions[c] + 1
+        y2 = self.row_positions[r + 1] if index_exists(self.row_positions, r + 1) else self.row_positions[r] + 1
         self.hide_selected()
         if self.PAR.ops.show_selected_cells_border:
             fill = ""
@@ -5809,12 +5801,16 @@ 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 = 8
         coords = rounded_box_coords(
             x1,
             y1,
             x2,
             y2,
-            radius=9 if self.PAR.ops.rounded_boxes else 0,
+            radius=radius,
         )
         if isinstance(iid, int):
             self.itemconfig(iid, fill=fill, outline=outline, state=state, tags=tags, width=width)
@@ -5844,7 +5840,7 @@ class MainTable(tk.Canvas):
             self.itemconfig(item, state="hidden")
 
     def hide_selection_box(self, item: int | None, set_current: bool = True) -> bool:
-        if item is None:
+        if item is None or item is True:
             return
         box = self.selection_boxes.pop(item)
         self.hide_box(box.fill_iid)
@@ -6048,7 +6044,7 @@ class MainTable(tk.Canvas):
             tags="cells" if type_ == "rows" else type_,
             iid=self.selection_boxes[fill_iid].header,
         )
-        if (bd_iid := self.selection_boxes[fill_iid].bd_iid):
+        if bd_iid := self.selection_boxes[fill_iid].bd_iid:
             if self.PAR.ops.show_selected_cells_border:
                 self.display_box(
                     x1,
@@ -6147,168 +6143,62 @@ class MainTable(tk.Canvas):
     def get_selected_rows(
         self,
         get_cells: bool = False,
-        within_range: tuple | None = None,
         get_cells_as_rows: bool = False,
     ) -> set[int] | set[tuple[int, int]]:
-        s = set()
-        if within_range is not None:
-            within_r1 = within_range[0]
-            within_r2 = within_range[1]
         if get_cells:
-            if within_range is None:
-                for item, box in self.get_selection_items(cells=False, columns=False):
-                    r1, c1, r2, c2 = box.coords
-                    s.update(set(product(range(r1, r2), range(0, len(self.col_positions) - 1))))
-                if get_cells_as_rows:
-                    s.update(self.get_selected_cells())
-            else:
-                for item, box in self.get_selection_items(cells=False, columns=False):
-                    r1, c1, r2, c2 = box.coords
-                    if r1 >= within_r1 or r2 <= within_r2:
-                        s.update(
-                            set(
-                                product(
-                                    range(r1 if r1 > within_r1 else within_r1, r2 if r2 < within_r2 else within_r2),
-                                    range(0, len(self.col_positions) - 1),
-                                )
-                            )
-                        )
-                if get_cells_as_rows:
-                    s.update(
-                        self.get_selected_cells(
-                            within_range=(
-                                within_r1,
-                                0,
-                                within_r2,
-                                len(self.col_positions) - 1,
-                            )
-                        )
-                    )
+            s = {
+                (r, c)
+                for item, box in self.get_selection_items(cells=False, columns=False)
+                for r in range(box.coords.from_r, box.coords.upto_r)
+                for c in range(0, len(self.col_positions) - 1)
+            }
+            if get_cells_as_rows:
+                return s | self.get_selected_cells()
         else:
-            if within_range is None:
-                for item, box in self.get_selection_items(cells=False, columns=False):
-                    r1, c1, r2, c2 = box.coords
-                    s.update(set(range(r1, r2)))
-                if get_cells_as_rows:
-                    s.update(set(tup[0] for tup in self.get_selected_cells()))
-            else:
-                for item, box in self.get_selection_items(cells=False, columns=False):
-                    r1, c1, r2, c2 = box.coords
-                    if r1 >= within_r1 or r2 <= within_r2:
-                        s.update(set(range(r1 if r1 > within_r1 else within_r1, r2 if r2 < within_r2 else within_r2)))
-                if get_cells_as_rows:
-                    s.update(
-                        set(
-                            tup[0]
-                            for tup in self.get_selected_cells(
-                                within_range=(
-                                    within_r1,
-                                    0,
-                                    within_r2,
-                                    len(self.col_positions) - 1,
-                                )
-                            )
-                        )
-                    )
+            s = {
+                r
+                for item, box in self.get_selection_items(cells=False, columns=False)
+                for r in range(box.coords.from_r, box.coords.upto_r)
+            }
+            if get_cells_as_rows:
+                return s | set(tup[0] for tup in self.get_selected_cells())
         return s
 
     def get_selected_cols(
         self,
         get_cells: bool = False,
-        within_range: tuple | None = None,
         get_cells_as_cols: bool = False,
     ) -> set[int] | set[tuple[int, int]]:
-        s = set()
-        if within_range is not None:
-            within_c1 = within_range[0]
-            within_c2 = within_range[1]
         if get_cells:
-            if within_range is None:
-                for item, box in self.get_selection_items(cells=False, rows=False):
-                    r1, c1, r2, c2 = box.coords
-                    s.update(set(product(range(c1, c2), range(0, len(self.row_positions) - 1))))
-                if get_cells_as_cols:
-                    s.update(self.get_selected_cells())
-            else:
-                for item, box in self.get_selection_items(cells=False, rows=False):
-                    r1, c1, r2, c2 = box.coords
-                    if c1 >= within_c1 or c2 <= within_c2:
-                        s.update(
-                            set(
-                                product(
-                                    range(c1 if c1 > within_c1 else within_c1, c2 if c2 < within_c2 else within_c2),
-                                    range(0, len(self.row_positions) - 1),
-                                )
-                            )
-                        )
-                if get_cells_as_cols:
-                    s.update(
-                        self.get_selected_cells(
-                            within_range=(
-                                0,
-                                within_c1,
-                                len(self.row_positions) - 1,
-                                within_c2,
-                            )
-                        )
-                    )
+            s = {
+                (r, c)
+                for item, box in self.get_selection_items(cells=False, rows=False)
+                for r in range(0, len(self.row_positions) - 1)
+                for c in range(box.coords.from_c, box.coords.upto_c)
+            }
+            if get_cells_as_cols:
+                return s | self.get_selected_cells()
         else:
-            if within_range is None:
-                for item, box in self.get_selection_items(cells=False, rows=False):
-                    r1, c1, r2, c2 = box.coords
-                    s.update(set(range(c1, c2)))
-                if get_cells_as_cols:
-                    s.update(set(tup[1] for tup in self.get_selected_cells()))
-            else:
-                for item in self.get_selection_items(cells=False, rows=False):
-                    r1, c1, r2, c2 = box.coords
-                    if c1 >= within_c1 or c2 <= within_c2:
-                        s.update(set(range(c1 if c1 > within_c1 else within_c1, c2 if c2 < within_c2 else within_c2)))
-                if get_cells_as_cols:
-                    s.update(
-                        set(
-                            tup[0]
-                            for tup in self.get_selected_cells(
-                                within_range=(
-                                    0,
-                                    within_c1,
-                                    len(self.row_positions) - 1,
-                                    within_c2,
-                                )
-                            )
-                        )
-                    )
+            s = {
+                c
+                for item, box in self.get_selection_items(cells=False, rows=False)
+                for c in range(box.coords.from_c, box.coords.upto_c)
+            }
+            if get_cells_as_cols:
+                return s | set(tup[1] for tup in self.get_selected_cells())
         return s
 
     def get_selected_cells(
         self,
         get_rows: bool = False,
         get_cols: bool = False,
-        within_range: bool = None,
     ) -> set[tuple[int, int]]:
-        s = set()
-        if within_range is not None:
-            within_r1 = within_range[0]
-            within_c1 = within_range[1]
-            within_r2 = within_range[2]
-            within_c2 = within_range[3]
-        if within_range is None:
-            for item, box in self.get_selection_items(rows=get_rows, columns=get_cols):
-                r1, c1, r2, c2 = box.coords
-                s.update(set(product(range(r1, r2), range(c1, c2))))
-        else:
-            for item in self.get_selection_items(rows=get_rows, columns=get_cols):
-                r1, c1, r2, c2 = box.coords
-                if r1 >= within_r1 or c1 >= within_c1 or r2 <= within_r2 or c2 <= within_c2:
-                    s.update(
-                        set(
-                            product(
-                                range(r1 if r1 > within_r1 else within_r1, r2 if r2 < within_r2 else within_r2),
-                                range(c1 if c1 > within_c1 else within_c1, c2 if c2 < within_c2 else within_c2),
-                            )
-                        )
-                    )
-        return s
+        return {
+            (r, c)
+            for item, box in self.get_selection_items(rows=get_rows, columns=get_cols)
+            for r in range(box.coords.from_r, box.coords.upto_r)
+            for c in range(box.coords.from_c, box.coords.upto_c)
+        }
 
     def get_all_selection_boxes(self) -> tuple[tuple[int, int, int, int]]:
         return tuple(box.coords for item, box in self.get_selection_items())
@@ -6469,7 +6359,9 @@ class MainTable(tk.Canvas):
                         sheet=self.PAR.name,
                         key=extra_func_key,
                         value=text,
-                        loc=(r, c),
+                        loc=Loc(r, c),
+                        row=r,
+                        column=c,
                         boxes=self.get_boxes(),
                         selected=self.selected,
                     )
@@ -6532,12 +6424,14 @@ class MainTable(tk.Canvas):
             self.text_editor.tktext.focus_set()
             self.text_editor.window.scroll_to_bottom()
         self.text_editor.tktext.bind("<Alt-Return>", lambda _x: self.text_editor_newline_binding(r, c))
+        self.text_editor.tktext.bind("<Alt-KP_Enter>", lambda _x: self.text_editor_newline_binding(r, c))
         if USER_OS == "darwin":
             self.text_editor.tktext.bind("<Option-Return>", lambda _x: self.text_editor_newline_binding(r, c))
         for key, func in self.text_editor_user_bound_keys.items():
             self.text_editor.tktext.bind(key, func)
         self.text_editor.tktext.bind("<Tab>", lambda _x: self.close_text_editor((r, c, "Tab")))
         self.text_editor.tktext.bind("<Return>", lambda _x: self.close_text_editor((r, c, "Return")))
+        self.text_editor.tktext.bind("<KP_Enter>", lambda _x: self.close_text_editor((r, c, "Return")))
         if not dropdown:
             self.text_editor.tktext.bind("<FocusOut>", lambda _x: self.close_text_editor((r, c, "FocusOut")))
         self.text_editor.tktext.bind("<Escape>", lambda _x: self.close_text_editor((r, c, "Escape")))
@@ -6627,8 +6521,8 @@ class MainTable(tk.Canvas):
 
     def hide_text_editor(self, reason: None | str = None) -> None:
         if self.text_editor.open:
-            for b in ("<Alt-Return>", "<Option-Return>", "<Tab>", "<Return>", "<FocusOut>", "<Escape>"):
-                self.text_editor.tktext.unbind(b)
+            for binding in text_editor_to_unbind:
+                self.text_editor.tktext.unbind(binding)
             self.itemconfig(self.text_editor.canvas_id, state="hidden")
             self.text_editor.open = False
         if reason == "Escape":
@@ -6660,7 +6554,9 @@ class MainTable(tk.Canvas):
             cells_table={(datarn, datacn): text_editor_value},
             key=editor_info[2],
             value=text_editor_value,
-            loc=(r, c),
+            loc=Loc(r, c),
+            row=r,
+            column=c,
             boxes=self.get_boxes(),
             selected=self.selected,
         )
@@ -6911,7 +6807,9 @@ class MainTable(tk.Canvas):
                         name="table_dropdown_modified",
                         sheet=self.PAR.name,
                         value=self.text_editor.get(),
-                        loc=(r, c),
+                        loc=Loc(r, c),
+                        row=r,
+                        column=c,
                         boxes=self.get_boxes(),
                         selected=self.selected,
                     )
@@ -6954,7 +6852,9 @@ class MainTable(tk.Canvas):
                 cells_table={(datarn, datacn): pre_edit_value},
                 key="??",
                 value=selection,
-                loc=(r, c),
+                loc=Loc(r, c),
+                row=r,
+                column=c,
                 boxes=self.get_boxes(),
                 selected=self.selected,
             )
@@ -7042,7 +6942,9 @@ class MainTable(tk.Canvas):
                 cells_table={(datarn, datacn): pre_edit_value},
                 key="??",
                 value=value,
-                loc=(r, c),
+                loc=Loc(r, c),
+                row=r,
+                column=c,
                 boxes=self.get_boxes(),
                 selected=self.selected,
             )
@@ -7161,7 +7063,7 @@ class MainTable(tk.Canvas):
 
     def fix_data_len(self, datarn: int, datacn: int | None = None) -> int:
         ncols = self.total_data_cols() if datacn is None else datacn + 1
-        self.data.extend([self.get_empty_row_seq(rn, end=ncols, start=0) for rn in range(len(self.data), datarn + 1)])
+        self.data.extend(self.get_empty_row_seq(rn, end=ncols, start=0) for rn in range(len(self.data), datarn + 1))
         return len(self.data)
 
     def reapply_formatting(self) -> None: