tksheet 7.1.6__py3-none-any.whl → 7.1.8__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,
-    get_checkbox_points,
     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:
@@ -999,101 +1000,104 @@ class MainTable(tk.Canvas):
                 tags: {full_new_idxs[k] for k in tagged} for tags, tagged in self.tagged_columns.items()
             }
             self.CH.cell_options = {full_new_idxs[k]: v for k, v in self.CH.cell_options.items()}
-            totalrows = self.total_data_rows()
-            new_ops = self.PAR.create_options_from_span
-            qkspan = self.span()
-            for span in self.named_spans.values():
-                # span is neither a cell options nor col options span, continue
-                if not isinstance(span["from_c"], int):
-                    continue
-                oldupto_colrange, newupto_colrange, newfrom, newupto = span_idxs_post_move(
-                    data_new_idxs,
-                    full_new_idxs,
-                    totalcols,
-                    span,
-                    "c",
-                )
-                # add cell/col kwargs for columns that are new to the span
-                old_span_idxs = set(full_new_idxs[k] for k in range(span["from_c"], oldupto_colrange))
-                for k in range(newfrom, newupto_colrange):
-                    if k not in old_span_idxs:
-                        oldidx = full_old_idxs[k]
-                        # event_data is used to preserve old cell value
-                        # in case cells are modified by
-                        # formatting, checkboxes, dropdown boxes
-                        if (
-                            span["type_"] in val_modifying_options
-                            and span["header"]
-                            and oldidx not in event_data["cells"]["header"]
-                        ):
-                            event_data["cells"]["header"][oldidx] = self.CH.get_cell_data(k)
-                        # the span targets columns
-                        if span["from_r"] is None:
-                            if span["type_"] in val_modifying_options:
-                                for datarn in range(len(self.data)):
-                                    if (datarn, oldidx) not in event_data["cells"]["table"]:
-                                        event_data["cells"]["table"][(datarn, oldidx)] = self.get_cell_data(datarn, k)
-                            # create new col options
-                            new_ops(
-                                mod_span(
-                                    qkspan,
-                                    span,
-                                    from_c=k,
-                                    upto_c=k + 1,
-                                )
-                            )
-                        # the span targets cells
-                        else:
-                            rng_upto_r = totalrows if span["upto_r"] is None else span["upto_r"]
-                            for datarn in range(span["from_r"], rng_upto_r):
-                                if (
-                                    span["type_"] in val_modifying_options
-                                    and (datarn, oldidx) not in event_data["cells"]["table"]
-                                ):
-                                    event_data["cells"]["table"][(datarn, oldidx)] = self.get_cell_data(datarn, k)
-                                # create new cell options
+            if self.named_spans:
+                totalrows = self.total_data_rows()
+                new_ops = self.PAR.create_options_from_span
+                qkspan = self.span()
+                for span in self.named_spans.values():
+                    # span is neither a cell options nor col options span, continue
+                    if not isinstance(span["from_c"], int):
+                        continue
+                    oldupto_colrange, newupto_colrange, newfrom, newupto = span_idxs_post_move(
+                        data_new_idxs,
+                        full_new_idxs,
+                        totalcols,
+                        span,
+                        "c",
+                    )
+                    # add cell/col kwargs for columns that are new to the span
+                    old_span_idxs = set(full_new_idxs[k] for k in range(span["from_c"], oldupto_colrange))
+                    for k in range(newfrom, newupto_colrange):
+                        if k not in old_span_idxs:
+                            oldidx = full_old_idxs[k]
+                            # event_data is used to preserve old cell value
+                            # in case cells are modified by
+                            # formatting, checkboxes, dropdown boxes
+                            if (
+                                span["type_"] in val_modifying_options
+                                and span["header"]
+                                and oldidx not in event_data["cells"]["header"]
+                            ):
+                                event_data["cells"]["header"][oldidx] = self.CH.get_cell_data(k)
+                            # the span targets columns
+                            if span["from_r"] is None:
+                                if span["type_"] in val_modifying_options:
+                                    for datarn in range(len(self.data)):
+                                        if (datarn, oldidx) not in event_data["cells"]["table"]:
+                                            event_data["cells"]["table"][(datarn, oldidx)] = self.get_cell_data(
+                                                datarn, k
+                                            )
+                                # create new col options
                                 new_ops(
                                     mod_span(
                                         qkspan,
                                         span,
-                                        from_r=datarn,
-                                        upto_r=datarn + 1,
                                         from_c=k,
                                         upto_c=k + 1,
                                     )
                                 )
-                # remove span specific kwargs from cells/columns
-                # that are no longer in the span,
-                # cell options/col options keys are new idxs
-                for k in range(span["from_c"], oldupto_colrange):
-                    # has it moved outside of new span coords
-                    if (isinstance(newupto, int) and (full_new_idxs[k] < newfrom or full_new_idxs[k] >= newupto)) or (
-                        newupto is None and full_new_idxs[k] < newfrom
-                    ):
-                        # span includes header
+                            # the span targets cells
+                            else:
+                                rng_upto_r = totalrows if span["upto_r"] is None else span["upto_r"]
+                                for datarn in range(span["from_r"], rng_upto_r):
+                                    if (
+                                        span["type_"] in val_modifying_options
+                                        and (datarn, oldidx) not in event_data["cells"]["table"]
+                                    ):
+                                        event_data["cells"]["table"][(datarn, oldidx)] = self.get_cell_data(datarn, k)
+                                    # create new cell options
+                                    new_ops(
+                                        mod_span(
+                                            qkspan,
+                                            span,
+                                            from_r=datarn,
+                                            upto_r=datarn + 1,
+                                            from_c=k,
+                                            upto_c=k + 1,
+                                        )
+                                    )
+                    # remove span specific kwargs from cells/columns
+                    # that are no longer in the span,
+                    # cell options/col options keys are new idxs
+                    for k in range(span["from_c"], oldupto_colrange):
+                        # has it moved outside of new span coords
                         if (
-                            span["header"]
-                            and full_new_idxs[k] in self.CH.cell_options
-                            and span["type_"] in self.CH.cell_options[full_new_idxs[k]]
-                        ):
-                            del self.CH.cell_options[full_new_idxs[k]][span["type_"]]
-                        # span is for col options
-                        if span["from_r"] is None:
+                            isinstance(newupto, int) and (full_new_idxs[k] < newfrom or full_new_idxs[k] >= newupto)
+                        ) or (newupto is None and full_new_idxs[k] < newfrom):
+                            # span includes header
                             if (
-                                full_new_idxs[k] in self.col_options
-                                and span["type_"] in self.col_options[full_new_idxs[k]]
+                                span["header"]
+                                and full_new_idxs[k] in self.CH.cell_options
+                                and span["type_"] in self.CH.cell_options[full_new_idxs[k]]
                             ):
-                                del self.col_options[full_new_idxs[k]][span["type_"]]
-                        # span is for cell options
-                        else:
-                            rng_upto_r = totalrows if span["upto_r"] is None else span["upto_r"]
-                            for r in range(span["from_r"], rng_upto_r):
-                                if (r, full_new_idxs[k]) in self.cell_options and span["type_"] in self.cell_options[
-                                    (r, full_new_idxs[k])
-                                ]:
-                                    del self.cell_options[(r, full_new_idxs[k])][span["type_"]]
-                # finally, change the span coords
-                span["from_c"], span["upto_c"] = newfrom, newupto
+                                del self.CH.cell_options[full_new_idxs[k]][span["type_"]]
+                            # span is for col options
+                            if span["from_r"] is None:
+                                if (
+                                    full_new_idxs[k] in self.col_options
+                                    and span["type_"] in self.col_options[full_new_idxs[k]]
+                                ):
+                                    del self.col_options[full_new_idxs[k]][span["type_"]]
+                            # span is for cell options
+                            else:
+                                rng_upto_r = totalrows if span["upto_r"] is None else span["upto_r"]
+                                for r in range(span["from_r"], rng_upto_r):
+                                    if (r, full_new_idxs[k]) in self.cell_options and span[
+                                        "type_"
+                                    ] in self.cell_options[(r, full_new_idxs[k])]:
+                                        del self.cell_options[(r, full_new_idxs[k])][span["type_"]]
+                    # finally, change the span coords
+                    span["from_c"], span["upto_c"] = newfrom, newupto
             if data_indexes:
                 self.displayed_columns = sorted(full_new_idxs[k] for k in self.displayed_columns)
         return data_new_idxs, disp_new_idxs, event_data
@@ -1192,7 +1196,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,
@@ -1216,101 +1220,104 @@ class MainTable(tk.Canvas):
             self.row_options = {full_new_idxs[k]: v for k, v in self.row_options.items()}
             self.RI.cell_options = {full_new_idxs[k]: v for k, v in self.RI.cell_options.items()}
             self.RI.tree_rns = {v: full_new_idxs[k] for v, k in self.RI.tree_rns.items()}
-            totalcols = self.total_data_cols()
-            new_ops = self.PAR.create_options_from_span
-            qkspan = self.span()
-            for span in self.named_spans.values():
-                # span is neither a cell options nor row options span, continue
-                if not isinstance(span["from_r"], int):
-                    continue
-                oldupto_rowrange, newupto_rowrange, newfrom, newupto = span_idxs_post_move(
-                    data_new_idxs,
-                    full_new_idxs,
-                    totalrows,
-                    span,
-                    "r",
-                )
-                # add cell/row kwargs for rows that are new to the span
-                old_span_idxs = set(full_new_idxs[k] for k in range(span["from_r"], oldupto_rowrange))
-                for k in range(newfrom, newupto_rowrange):
-                    if k not in old_span_idxs:
-                        oldidx = full_old_idxs[k]
-                        # event_data is used to preserve old cell value
-                        # in case cells are modified by
-                        # formatting, checkboxes, dropdown boxes
-                        if (
-                            span["type_"] in val_modifying_options
-                            and span["index"]
-                            and oldidx not in event_data["cells"]["index"]
-                        ):
-                            event_data["cells"]["index"][oldidx] = self.RI.get_cell_data(k)
-                        # the span targets rows
-                        if span["from_c"] is None:
-                            if span["type_"] in val_modifying_options:
-                                for datacn in range(len(self.data[k])):
-                                    if (oldidx, datacn) not in event_data["cells"]["table"]:
-                                        event_data["cells"]["table"][(oldidx, datacn)] = self.get_cell_data(k, datacn)
-                            # create new row options
-                            new_ops(
-                                mod_span(
-                                    qkspan,
-                                    span,
-                                    from_r=k,
-                                    upto_r=k + 1,
-                                )
-                            )
-                        # the span targets cells
-                        else:
-                            rng_upto_c = totalcols if span["upto_c"] is None else span["upto_c"]
-                            for datacn in range(span["from_c"], rng_upto_c):
-                                if (
-                                    span["type_"] in val_modifying_options
-                                    and (oldidx, datacn) not in event_data["cells"]["table"]
-                                ):
-                                    event_data["cells"]["table"][(oldidx, datacn)] = self.get_cell_data(k, datacn)
-                                # create new cell options
+            if self.named_spans:
+                totalcols = self.total_data_cols()
+                new_ops = self.PAR.create_options_from_span
+                qkspan = self.span()
+                for span in self.named_spans.values():
+                    # span is neither a cell options nor row options span, continue
+                    if not isinstance(span["from_r"], int):
+                        continue
+                    oldupto_rowrange, newupto_rowrange, newfrom, newupto = span_idxs_post_move(
+                        data_new_idxs,
+                        full_new_idxs,
+                        totalrows,
+                        span,
+                        "r",
+                    )
+                    # add cell/row kwargs for rows that are new to the span
+                    old_span_idxs = set(full_new_idxs[k] for k in range(span["from_r"], oldupto_rowrange))
+                    for k in range(newfrom, newupto_rowrange):
+                        if k not in old_span_idxs:
+                            oldidx = full_old_idxs[k]
+                            # event_data is used to preserve old cell value
+                            # in case cells are modified by
+                            # formatting, checkboxes, dropdown boxes
+                            if (
+                                span["type_"] in val_modifying_options
+                                and span["index"]
+                                and oldidx not in event_data["cells"]["index"]
+                            ):
+                                event_data["cells"]["index"][oldidx] = self.RI.get_cell_data(k)
+                            # the span targets rows
+                            if span["from_c"] is None:
+                                if span["type_"] in val_modifying_options:
+                                    for datacn in range(len(self.data[k])):
+                                        if (oldidx, datacn) not in event_data["cells"]["table"]:
+                                            event_data["cells"]["table"][(oldidx, datacn)] = self.get_cell_data(
+                                                k, datacn
+                                            )
+                                # create new row options
                                 new_ops(
                                     mod_span(
                                         qkspan,
                                         span,
                                         from_r=k,
                                         upto_r=k + 1,
-                                        from_c=datacn,
-                                        upto_c=datacn + 1,
                                     )
                                 )
-                # remove span specific kwargs from cells/rows
-                # that are no longer in the span,
-                # cell options/row options keys are new idxs
-                for k in range(span["from_r"], oldupto_rowrange):
-                    # has it moved outside of new span coords
-                    if (isinstance(newupto, int) and (full_new_idxs[k] < newfrom or full_new_idxs[k] >= newupto)) or (
-                        newupto is None and full_new_idxs[k] < newfrom
-                    ):
-                        # span includes index
+                            # the span targets cells
+                            else:
+                                rng_upto_c = totalcols if span["upto_c"] is None else span["upto_c"]
+                                for datacn in range(span["from_c"], rng_upto_c):
+                                    if (
+                                        span["type_"] in val_modifying_options
+                                        and (oldidx, datacn) not in event_data["cells"]["table"]
+                                    ):
+                                        event_data["cells"]["table"][(oldidx, datacn)] = self.get_cell_data(k, datacn)
+                                    # create new cell options
+                                    new_ops(
+                                        mod_span(
+                                            qkspan,
+                                            span,
+                                            from_r=k,
+                                            upto_r=k + 1,
+                                            from_c=datacn,
+                                            upto_c=datacn + 1,
+                                        )
+                                    )
+                    # remove span specific kwargs from cells/rows
+                    # that are no longer in the span,
+                    # cell options/row options keys are new idxs
+                    for k in range(span["from_r"], oldupto_rowrange):
+                        # has it moved outside of new span coords
                         if (
-                            span["index"]
-                            and full_new_idxs[k] in self.RI.cell_options
-                            and span["type_"] in self.RI.cell_options[full_new_idxs[k]]
-                        ):
-                            del self.RI.cell_options[full_new_idxs[k]][span["type_"]]
-                        # span is for row options
-                        if span["from_c"] is None:
+                            isinstance(newupto, int) and (full_new_idxs[k] < newfrom or full_new_idxs[k] >= newupto)
+                        ) or (newupto is None and full_new_idxs[k] < newfrom):
+                            # span includes index
                             if (
-                                full_new_idxs[k] in self.row_options
-                                and span["type_"] in self.row_options[full_new_idxs[k]]
+                                span["index"]
+                                and full_new_idxs[k] in self.RI.cell_options
+                                and span["type_"] in self.RI.cell_options[full_new_idxs[k]]
                             ):
-                                del self.row_options[full_new_idxs[k]][span["type_"]]
-                        # span is for cell options
-                        else:
-                            rng_upto_c = totalcols if span["upto_c"] is None else span["upto_c"]
-                            for c in range(span["from_c"], rng_upto_c):
-                                if (full_new_idxs[k], c) in self.cell_options and span["type_"] in self.cell_options[
-                                    (full_new_idxs[k], c)
-                                ]:
-                                    del self.cell_options[(full_new_idxs[k], c)][span["type_"]]
-                # finally, change the span coords
-                span["from_r"], span["upto_r"] = newfrom, newupto
+                                del self.RI.cell_options[full_new_idxs[k]][span["type_"]]
+                            # span is for row options
+                            if span["from_c"] is None:
+                                if (
+                                    full_new_idxs[k] in self.row_options
+                                    and span["type_"] in self.row_options[full_new_idxs[k]]
+                                ):
+                                    del self.row_options[full_new_idxs[k]][span["type_"]]
+                            # span is for cell options
+                            else:
+                                rng_upto_c = totalcols if span["upto_c"] is None else span["upto_c"]
+                                for c in range(span["from_c"], rng_upto_c):
+                                    if (full_new_idxs[k], c) in self.cell_options and span[
+                                        "type_"
+                                    ] in self.cell_options[(full_new_idxs[k], c)]:
+                                        del self.cell_options[(full_new_idxs[k], c)][span["type_"]]
+                    # finally, change the span coords
+                    span["from_r"], span["upto_r"] = newfrom, newupto
             if data_indexes:
                 self.displayed_rows = sorted(full_new_idxs[k] for k in self.displayed_rows)
         return data_new_idxs, disp_new_idxs, event_data
@@ -2785,6 +2792,7 @@ class MainTable(tk.Canvas):
         c = self.identify_col(x=event.x)
         if self.single_selection_enabled and self.not_currently_resizing():
             if r < len(self.row_positions) - 1 and c < len(self.col_positions) - 1:
+                self.being_drawn_item = True
                 self.being_drawn_item = self.select_cell(r, c, redraw=True)
         elif self.toggle_selection_enabled and self.not_currently_resizing():
             r = self.identify_row(y=event.y)
@@ -3021,7 +3029,11 @@ class MainTable(tk.Canvas):
                 c_to_sel,
                 item=self.create_selection_box(
                     *to_sel,
-                    state="hidden" if (to_sel[2] - to_sel[0] == 1 and to_sel[3] - to_sel[1] == 1) else "normal",
+                    state=(
+                        "hidden"
+                        if (to_sel.upto_r - to_sel.from_r == 1 and to_sel.upto_c - to_sel.from_c == 1)
+                        else "normal"
+                    ),
                     set_current=False,
                 ),
             )
@@ -3202,39 +3214,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:
@@ -4882,7 +4885,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:
@@ -5147,7 +5150,7 @@ class MainTable(tk.Canvas):
         tag: str | tuple,
         draw_check: bool = False,
     ) -> None:
-        points = get_checkbox_points(x1, y1, x2, y2)
+        points = rounded_box_coords(x1, y1, x2, y2)
         if self.hidd_checkbox:
             t, sh = self.hidd_checkbox.popitem()
             self.coords(t, points)
@@ -5164,7 +5167,7 @@ class MainTable(tk.Canvas):
             y1 = y1 + 4
             x2 = x2 - 3
             y2 = y2 - 3
-            points = get_checkbox_points(x1, y1, x2, y2, radius=4)
+            points = rounded_box_coords(x1, y1, x2, y2, radius=4)
             if self.hidd_checkbox:
                 t, sh = self.hidd_checkbox.popitem()
                 self.coords(t, points)
@@ -5182,6 +5185,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()
@@ -5275,6 +5279,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]:
@@ -5754,8 +5760,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 = ""
@@ -5796,24 +5802,38 @@ class MainTable(tk.Canvas):
         state: str,
         tags: str | tuple[str],
         width: int,
+        iid: None | int = None,
     ) -> int:
-        if self.hidd_boxes:
-            iid = self.hidd_boxes.pop()
+        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=radius,
+        )
+        if isinstance(iid, int):
             self.itemconfig(iid, fill=fill, outline=outline, state=state, tags=tags, width=width)
-            self.coords(iid, x1, y1, x2, y2)
+            self.coords(iid, coords)
         else:
-            iid = self.create_rectangle(
-                x1,
-                y1,
-                x2,
-                y2,
-                fill=fill,
-                outline=outline,
-                state=state,
-                tags=tags,
-                width=width,
-            )
-        self.disp_boxes.add(iid)
+            if self.hidd_boxes:
+                iid = self.hidd_boxes.pop()
+                self.itemconfig(iid, fill=fill, outline=outline, state=state, tags=tags, width=width)
+                self.coords(iid, coords)
+            else:
+                iid = self.create_polygon(
+                    coords,
+                    fill=fill,
+                    outline=outline,
+                    state=state,
+                    tags=tags,
+                    width=width,
+                    smooth=True,
+                )
+            self.disp_boxes.add(iid)
         return iid
 
     def hide_box(self, item: int | None) -> None:
@@ -5823,7 +5843,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)
@@ -5866,29 +5886,32 @@ class MainTable(tk.Canvas):
         elif type_ == "columns":
             mt_bg = self.PAR.ops.table_selected_columns_bg
             mt_border_col = self.PAR.ops.table_selected_columns_border_fg
+        if self.selection_boxes:
+            self.itemconfig(next(reversed(self.selection_boxes)), state="normal")
+        x1, y1, x2, y2 = self.box_sheet_coords_x_canvas_coords(r1, c1, r2, c2, type_)
         fill_iid = self.display_box(
-            self.col_positions[c1],
-            self.row_positions[r1],
-            self.canvasx(self.winfo_width()) if self.PAR.ops.selected_rows_to_end_of_window else self.col_positions[c2],
-            self.row_positions[r2],
+            x1,
+            y1,
+            x2,
+            y2,
             fill=mt_bg,
             outline="",
-            state=state,
+            state=state if self.PAR.ops.show_selected_cells_border else "normal",
             tags=type_,
             width=1,
         )
         index_iid = self.RI.display_box(
-            0,
-            self.row_positions[r1],
+            1,
+            y1,
             self.RI.current_width - 1,
-            self.row_positions[r2],
+            y2,
             fill=self.PAR.ops.index_selected_rows_bg if type_ == "rows" else self.PAR.ops.index_selected_cells_bg,
             outline="",
             state="normal",
             tags="cells" if type_ == "columns" else type_,
         )
         header_iid = self.CH.display_box(
-            self.col_positions[c1],
+            x1,
             0,
             self.col_positions[c2],
             self.CH.current_height - 1,
@@ -5905,10 +5928,10 @@ class MainTable(tk.Canvas):
             or self.selection_boxes
         ):
             bd_iid = self.display_box(
-                self.col_positions[c1],
-                self.row_positions[r1],
-                self.col_positions[c2],
-                self.row_positions[r2],
+                x1,
+                y1,
+                x2,
+                y2,
                 fill="",
                 outline=mt_border_col,
                 state="normal",
@@ -5951,6 +5974,23 @@ class MainTable(tk.Canvas):
             if self.PAR.ops.show_selected_cells_border:
                 self.tag_raise(self.selected.iid)
 
+    def box_sheet_coords_x_canvas_coords(
+        self,
+        r1: int,
+        c1: int,
+        r2: int,
+        c2: int,
+        type_: Literal["cells", "rows", "columns"],
+    ) -> tuple[float, float, float, float]:
+        x1 = self.col_positions[c1]
+        y1 = self.row_positions[r1]
+        y2 = self.row_positions[r2]
+        if type_ == "rows" and self.PAR.ops.selected_rows_to_end_of_window:
+            x2 = self.canvasx(self.winfo_width())
+        else:
+            x2 = self.col_positions[c2]
+        return x1, y1, x2, y2
+
     def recreate_selection_box(
         self,
         r1: int,
@@ -5973,66 +6013,53 @@ class MainTable(tk.Canvas):
             mt_bg = self.PAR.ops.table_selected_columns_bg
             mt_border_col = self.PAR.ops.table_selected_columns_border_fg
         if not state:
-            state = "normal" if (r2 - r1 > 1 or c2 - c1 > 1) else "hidden"
+            if r2 - r1 > 1 or c2 - c1 > 1:
+                state = "normal"
+            elif next(reversed(self.selection_boxes)) == fill_iid:
+                state = "hidden"
+            else:
+                state = "normal"
         if self.selected.fill_iid == fill_iid:
             self.selected = self.selected._replace(box=Box_nt(r1, c1, r2, c2))
-        self.coords(
-            fill_iid,
-            self.col_positions[c1],
-            self.row_positions[r1],
-            self.canvasx(self.winfo_width()) if self.PAR.ops.selected_rows_to_end_of_window else self.col_positions[c2],
-            self.row_positions[r2],
-        )
-        self.itemconfig(
-            fill_iid,
-            fill=mt_bg,
-            outline="",
-            tags=type_,
-            state=state,
-        )
-        self.RI.coords(
-            self.selection_boxes[fill_iid].index,
-            0,
-            self.row_positions[r1],
+        x1, y1, x2, y2 = self.box_sheet_coords_x_canvas_coords(r1, c1, r2, c2, type_)
+        self.display_box(x1, y1, x2, y2, fill=mt_bg, outline="", state=state, tags=type_, width=1, iid=fill_iid)
+        self.RI.display_box(
+            1,
+            y1,
             self.RI.current_width - 1,
-            self.row_positions[r2],
-        )
-        self.RI.itemconfig(
-            self.selection_boxes[fill_iid].index,
+            y2,
             fill=self.PAR.ops.index_selected_rows_bg if type_ == "rows" else self.PAR.ops.index_selected_cells_bg,
             outline="",
+            state="normal",
             tags="cells" if type_ == "columns" else type_,
+            iid=self.selection_boxes[fill_iid].index,
         )
-        self.CH.coords(
-            self.selection_boxes[fill_iid].header,
-            self.col_positions[c1],
+        self.CH.display_box(
+            x1,
             0,
             self.col_positions[c2],
             self.CH.current_height - 1,
-        )
-        self.CH.itemconfig(
-            self.selection_boxes[fill_iid].header,
             fill=(
                 self.PAR.ops.header_selected_columns_bg if type_ == "columns" else self.PAR.ops.header_selected_cells_bg
             ),
             outline="",
+            state="normal",
             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 self.PAR.ops.show_selected_cells_border:
-                self.coords(
-                    bd_iid,
-                    self.col_positions[c1],
-                    self.row_positions[r1],
-                    self.col_positions[c2],
-                    self.row_positions[r2],
-                )
-                self.itemconfig(
-                    bd_iid,
+                self.display_box(
+                    x1,
+                    y1,
+                    x2,
+                    y2,
                     fill="",
                     outline=mt_border_col,
-                    tags=f"{type_}bd",
                     state="normal",
+                    tags=f"{type_}bd",
+                    width=1,
+                    iid=bd_iid,
                 )
                 self.tag_raise(bd_iid)
             else:
@@ -6079,23 +6106,23 @@ class MainTable(tk.Canvas):
                 self.set_currently_selected(box.coords.from_r, box.coords.from_c, item=box.fill_iid)
 
     def get_redraw_selections(self, startr: int, endr: int, startc: int, endc: int) -> dict:
-        d = defaultdict(list)
+        d = defaultdict(set)
         for item, box in self.get_selection_items():
-            d[box.type_].append(box.coords)
-        d2 = {}
-        if "cells" in d:
-            d2["cells"] = {
-                (r, c)
-                for r in range(startr, endr)
-                for c in range(startc, endc)
-                for r1, c1, r2, c2 in d["cells"]
-                if r1 <= r and c1 <= c and r2 > r and c2 > c
-            }
-        if "rows" in d:
-            d2["rows"] = {r for r in range(startr, endr) for r1, c1, r2, c2 in d["rows"] if r1 <= r and r2 > r}
-        if "columns" in d:
-            d2["columns"] = {c for c in range(startc, endc) for r1, c1, r2, c2 in d["columns"] if c1 <= c and c2 > c}
-        return d2
+            r1, c1, r2, c2 = box.coords
+            if box.type_ == "cells":
+                for r in range(startr, endr):
+                    for c in range(startc, endc):
+                        if r1 <= r and c1 <= c and r2 > r and c2 > c:
+                            d["cells"].add((r, c))
+            elif box.type_ == "rows":
+                for r in range(startr, endr):
+                    if r1 <= r and r2 > r:
+                        d["rows"].add(r)
+            elif box.type_ == "columns":
+                for c in range(startc, endc):
+                    if c1 <= c and c2 > c:
+                        d["columns"].add(c)
+        return d
 
     def get_selected_min_max(self) -> tuple[int, int, int, int] | tuple[None, None, None, None]:
         min_x = float("inf")
@@ -6119,168 +6146,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())
@@ -6441,7 +6362,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,
                     )
@@ -6504,12 +6427,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")))
@@ -6599,6 +6524,8 @@ class MainTable(tk.Canvas):
 
     def hide_text_editor(self, reason: None | str = None) -> None:
         if self.text_editor.open:
+            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":
@@ -6621,16 +6548,18 @@ class MainTable(tk.Canvas):
             self.hide_text_editor_and_dropdown()
             return
         # setting cell data with text editor value
-        self.text_editor_value = self.text_editor.get()
+        text_editor_value = self.text_editor.get()
         r, c = editor_info[0], editor_info[1]
         datarn, datacn = self.datarn(r), self.datacn(c)
         event_data = event_dict(
             name="end_edit_table",
             sheet=self.PAR.name,
-            cells_table={(datarn, datacn): self.text_editor_value},
+            cells_table={(datarn, datacn): text_editor_value},
             key=editor_info[2],
-            value=self.text_editor_value,
-            loc=(r, c),
+            value=text_editor_value,
+            loc=Loc(r, c),
+            row=r,
+            column=c,
             boxes=self.get_boxes(),
             selected=self.selected,
         )
@@ -6645,11 +6574,11 @@ class MainTable(tk.Canvas):
             check_input_valid=False,
         )
         if self.edit_validation_func:
-            self.text_editor_value = self.edit_validation_func(event_data)
-            if self.text_editor_value is not None and self.input_valid_for_cell(datarn, datacn, self.text_editor_value):
-                edited = set_data(value=self.text_editor_value)
-        elif self.input_valid_for_cell(datarn, datacn, self.text_editor_value):
-            edited = set_data(value=self.text_editor_value)
+            text_editor_value = self.edit_validation_func(event_data)
+            if text_editor_value is not None and self.input_valid_for_cell(datarn, datacn, text_editor_value):
+                edited = set_data(value=text_editor_value)
+        elif self.input_valid_for_cell(datarn, datacn, text_editor_value):
+            edited = set_data(value=text_editor_value)
         if edited:
             try_binding(self.extra_end_edit_cell_func, event_data)
         if (
@@ -6659,7 +6588,7 @@ class MainTable(tk.Canvas):
             and r == self.selected.row
             and c == self.selected.column
             and (self.single_selection_enabled or self.toggle_selection_enabled)
-            and (edited or self.cell_equal_to(datarn, datacn, self.text_editor_value))
+            and (edited or self.cell_equal_to(datarn, datacn, text_editor_value))
         ):
             r1, c1, r2, c2 = self.selection_boxes[self.selected.fill_iid].coords
             numcols = c2 - c1
@@ -6881,7 +6810,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,
                     )
@@ -6924,7 +6855,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,
             )
@@ -6977,6 +6910,7 @@ class MainTable(tk.Canvas):
 
     def hide_dropdown_window(self) -> None:
         if self.dropdown.open:
+            self.dropdown.window.unbind("<FocusOut>")
             self.itemconfig(self.dropdown.canvas_id, state="hidden")
             self.dropdown.open = False
 
@@ -7011,7 +6945,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,
             )
@@ -7028,12 +6964,14 @@ class MainTable(tk.Canvas):
         c: int = 0,
         datarn: int | None = None,
         datacn: int | None = None,
-        value: str = "",
+        value: str | None = None,
         undo: bool = True,
         cell_resize: bool = True,
         redraw: bool = True,
         check_input_valid: bool = True,
     ) -> bool:
+        if value is None:
+            value = ""
         if datacn is None:
             datacn = self.datacn(c)
         if datarn is None:
@@ -7128,7 +7066,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: