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

tksheet/main_table.py

@@ -56,7 +56,7 @@ from .functions import (
     ev_stack_dict,
     event_dict,
     gen_formatted,
-    get_checkbox_points,
+    rounded_box_coords,
     get_new_indexes,
     get_seq_without_gaps_at_index,
     index_exists,
@@ -999,101 +999,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
@@ -1216,101 +1219,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 +2791,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 +3028,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,
                 ),
             )
@@ -5147,7 +5158,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 +5175,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)
@@ -5796,24 +5807,34 @@ 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()
+        coords = rounded_box_coords(
+            x1,
+            y1,
+            x2,
+            y2,
+            radius=9 if self.PAR.ops.rounded_boxes else 0,
+        )
+        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:
@@ -5866,29 +5887,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 +5929,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 +5975,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 +6014,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 (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 +6107,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")
@@ -6599,6 +6627,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)
             self.itemconfig(self.text_editor.canvas_id, state="hidden")
             self.text_editor.open = False
         if reason == "Escape":
@@ -6621,15 +6651,15 @@ 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,
+            value=text_editor_value,
             loc=(r, c),
             boxes=self.get_boxes(),
             selected=self.selected,
@@ -6645,11 +6675,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 +6689,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
@@ -6977,6 +7007,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
 
@@ -7028,12 +7059,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: