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

tksheet/main_table.py

@@ -49,18 +49,19 @@ from .formatters import (
     try_to_bool,
 )
 from .functions import (
-    consecutive_chunks,
+    consecutive_ranges,
     decompress_load,
     diff_gen,
     diff_list,
     ev_stack_dict,
     event_dict,
     gen_formatted,
-    get_checkbox_points,
+    rounded_box_coords,
     get_new_indexes,
     get_seq_without_gaps_at_index,
     index_exists,
     insert_items,
+    int_x_iter,
     is_iterable,
     is_type_int,
     len_to_idx,
@@ -960,12 +961,12 @@ class MainTable(tk.Canvas):
                 )
             )
             if create_selections:
-                for chunk in consecutive_chunks(sorted(disp_new_idxs.values())):
+                for boxst, boxend in consecutive_ranges(sorted(disp_new_idxs.values())):
                     self.create_selection_box(
                         0,
-                        chunk[0],
+                        boxst,
                         len(self.row_positions) - 1,
-                        chunk[-1] + 1,
+                        boxend,
                         "columns",
                         run_binding=True,
                     )
@@ -998,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
@@ -1181,11 +1185,11 @@ class MainTable(tk.Canvas):
                 )
             )
             if create_selections:
-                for chunk in consecutive_chunks(sorted(disp_new_idxs.values())):
+                for boxst, boxend in consecutive_ranges(sorted(disp_new_idxs.values())):
                     self.create_selection_box(
-                        chunk[0],
+                        boxst,
                         0,
-                        chunk[-1] + 1,
+                        boxend,
                         len(self.col_positions) - 1,
                         "rows",
                         run_binding=True,
@@ -1215,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
@@ -1846,7 +1853,6 @@ class MainTable(tk.Canvas):
                                 "rows",
                                 set_current=resel and to_sel >= r + 1 and to_sel < r2,
                             )
-                    break
         elif isinstance(c, int) and r is None and cell is None:
             for item, box in self.get_selection_items(rows=False, cells=False):
                 r1, c1, r2, c2 = box.coords
@@ -1890,7 +1896,6 @@ class MainTable(tk.Canvas):
                                 "columns",
                                 set_current=resel and to_sel >= c + 1 and to_sel < c2,
                             )
-                    break
         elif (isinstance(r, int) and isinstance(c, int) and cell is None) or cell is not None:
             if cell is not None:
                 r, c = cell[0], cell[1]
@@ -1898,7 +1903,6 @@ class MainTable(tk.Canvas):
                 r1, c1, r2, c2 = box.coords
                 if r >= r1 and c >= c1 and r < r2 and c < c2:
                     self.hide_selection_box(item)
-                    break
         if redraw:
             self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
         sel_event = self.get_select_event(being_drawn_item=self.being_drawn_item)
@@ -1906,7 +1910,51 @@ class MainTable(tk.Canvas):
             try_binding(self.deselection_binding_func, sel_event)
         self.PAR.emit_event("<<SheetSelect>>", data=sel_event)
 
-    def page_UP(self, event=None):
+    def deselect_any(
+        self,
+        rows: Iterator[int] | int | None = None,
+        columns: Iterator[int] | int | None = None,
+        redraw: bool = True,
+    ) -> None:
+        rows = int_x_iter(rows)
+        columns = int_x_iter(columns)
+        if is_iterable(rows) and is_iterable(columns):
+            rows = tuple(consecutive_ranges(sorted(rows)))
+            columns = tuple(consecutive_ranges(sorted(columns)))
+            for item, box in self.get_selection_items(reverse=True):
+                r1, c1, r2, c2 = box.coords
+                hidden = False
+                for rows_st, rows_end in rows:
+                    if hidden:
+                        break
+                    for cols_st, cols_end in columns:
+                        if ((rows_end >= r1 and rows_end <= r2) or (rows_st >= r1 and rows_st < r2)) and (
+                            (cols_end >= c1 and cols_end <= c2) or (cols_st >= c1 and cols_st < c2)
+                        ):
+                            hidden = self.hide_selection_box(item)
+                            break
+        elif is_iterable(rows):
+            rows = tuple(consecutive_ranges(sorted(rows)))
+            for item, box in self.get_selection_items(reverse=True):
+                r1, c1, r2, c2 = box.coords
+                for rows_st, rows_end in rows:
+                    if (rows_end >= r1 and rows_end <= r2) or (rows_st >= r1 and rows_st < r2):
+                        self.hide_selection_box(item)
+                        break
+        elif is_iterable(columns):
+            columns = tuple(consecutive_ranges(sorted(columns)))
+            for item, box in self.get_selection_items(reverse=True):
+                r1, c1, r2, c2 = box.coords
+                for cols_st, cols_end in columns:
+                    if (cols_end >= c1 and cols_end <= c2) or (cols_st >= c1 and cols_st < c2):
+                        self.hide_selection_box(item)
+                        break
+        else:
+            self.deselect()
+        if redraw:
+            self.refresh()
+
+    def page_UP(self, event: object = None) -> None:
         height = self.winfo_height()
         top = self.canvasy(0)
         scrollto_y = top - height
@@ -1935,7 +1983,7 @@ class MainTable(tk.Canvas):
             self.RI.yview(*args)
             self.main_table_redraw_grid_and_text(redraw_row_index=True)
 
-    def page_DOWN(self, event=None):
+    def page_DOWN(self, event: object = None) -> None:
         height = self.winfo_height()
         top = self.canvasy(0)
         scrollto = top + height
@@ -1965,7 +2013,7 @@ class MainTable(tk.Canvas):
             self.RI.yview(*args)
             self.main_table_redraw_grid_and_text(redraw_row_index=True)
 
-    def arrowkey_UP(self, event=None):
+    def arrowkey_UP(self, event: object = None) -> None:
         if not self.selected:
             return
         if self.selected.type_ == "rows":
@@ -1989,7 +2037,7 @@ class MainTable(tk.Canvas):
                     self.select_cell(r - 1, c)
                     self.see(r - 1, c, keep_xscroll=True, check_cell_visibility=False)
 
-    def arrowkey_DOWN(self, event=None):
+    def arrowkey_DOWN(self, event: object = None) -> None:
         if not self.selected:
             return
         if self.selected.type_ == "rows":
@@ -2068,7 +2116,7 @@ class MainTable(tk.Canvas):
                             check_cell_visibility=False,
                         )
 
-    def arrowkey_LEFT(self, event=None):
+    def arrowkey_LEFT(self, event: object = None) -> None:
         if not self.selected:
             return
         if self.selected.type_ == "columns":
@@ -2100,7 +2148,7 @@ class MainTable(tk.Canvas):
                     self.select_cell(r, c - 1)
                     self.see(r, c - 1, keep_yscroll=True, check_cell_visibility=False)
 
-    def arrowkey_RIGHT(self, event=None):
+    def arrowkey_RIGHT(self, event: object = None) -> None:
         if not self.selected:
             return
         if self.selected.type_ == "rows":
@@ -2743,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)
@@ -2979,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,
                 ),
             )
@@ -3222,8 +3275,6 @@ class MainTable(tk.Canvas):
 
     def ctrl_mousewheel(self, event):
         if event.delta < 0 or event.num == 5:
-            if self.PAR.ops.table_font[1] < 2 or self.PAR.ops.index_font[1] < 2 or self.PAR.ops.header_font[1] < 2:
-                return
             self.zoom_out()
         elif event.delta >= 0 or event.num == 4:
             self.zoom_in()
@@ -3231,16 +3282,22 @@ class MainTable(tk.Canvas):
     def zoom_in(self, event=None):
         self.zoom_font(
             (self.PAR.ops.table_font[0], self.PAR.ops.table_font[1] + 1, self.PAR.ops.table_font[2]),
+            (self.PAR.ops.index_font[0], self.PAR.ops.index_font[1] + 1, self.PAR.ops.index_font[2]),
             (self.PAR.ops.header_font[0], self.PAR.ops.header_font[1] + 1, self.PAR.ops.header_font[2]),
+            "in",
         )
 
     def zoom_out(self, event=None):
+        if self.PAR.ops.table_font[1] < 2 or self.PAR.ops.index_font[1] < 2 or self.PAR.ops.header_font[1] < 2:
+            return
         self.zoom_font(
             (self.PAR.ops.table_font[0], self.PAR.ops.table_font[1] - 1, self.PAR.ops.table_font[2]),
+            (self.PAR.ops.index_font[0], self.PAR.ops.index_font[1] - 1, self.PAR.ops.index_font[2]),
             (self.PAR.ops.header_font[0], self.PAR.ops.header_font[1] - 1, self.PAR.ops.header_font[2]),
+            "out",
         )
 
-    def zoom_font(self, table_font: tuple, header_font: tuple):
+    def zoom_font(self, table_font: tuple, index_font: tuple, header_font: tuple, zoom: Literal["in", "out"]) -> None:
         self.saved_column_widths = {}
         self.saved_row_heights = {}
         # should record position prior to change and then see after change
@@ -3262,7 +3319,7 @@ class MainTable(tk.Canvas):
             table_font,
             reset_row_positions=False,
         )
-        self.set_index_font(table_font)
+        self.set_index_font(index_font)
         self.set_header_font(header_font)
         if self.PAR.ops.set_cell_sizes_on_zoom:
             self.set_all_cell_sizes_to_text()
@@ -3290,18 +3347,18 @@ class MainTable(tk.Canvas):
             )
             self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
             self.recreate_all_selection_boxes()
-        self.refresh_open_window_positions()
-        self.RI.refresh_open_window_positions()
-        self.CH.refresh_open_window_positions()
+        self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
+        self.refresh_open_window_positions(zoom=zoom)
+        self.RI.refresh_open_window_positions(zoom=zoom)
+        self.CH.refresh_open_window_positions(zoom=zoom)
         self.see(
             r,
             c,
             check_cell_visibility=False,
-            redraw=False,
+            redraw=True,
             r_pc=r_pc,
             c_pc=c_pc,
         )
-        self.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
 
     def get_txt_w(self, txt, font=None):
         self.txt_measure_canvas.itemconfig(
@@ -4207,12 +4264,12 @@ class MainTable(tk.Canvas):
         )
         if create_selections:
             self.deselect("all")
-            for chunk in consecutive_chunks(tuple(reversed(column_widths))):
+            for boxst, boxend in consecutive_ranges(tuple(reversed(column_widths))):
                 self.create_selection_box(
                     0,
-                    chunk[0],
+                    boxst,
                     len(self.row_positions) - 1,
-                    chunk[-1] + 1,
+                    boxend,
                     "columns",
                     run_binding=True,
                 )
@@ -4336,11 +4393,11 @@ class MainTable(tk.Canvas):
         )
         if create_selections:
             self.deselect("all")
-            for chunk in consecutive_chunks(tuple(reversed(row_heights))):
+            for boxst, boxend in consecutive_ranges(tuple(reversed(row_heights))):
                 self.create_selection_box(
-                    chunk[0],
+                    boxst,
                     0,
-                    chunk[-1] + 1,
+                    boxend,
                     len(self.col_positions) - 1,
                     "rows",
                     run_binding=True,
@@ -5101,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)
@@ -5118,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)
@@ -5620,7 +5677,7 @@ class MainTable(tk.Canvas):
             if r2 < len(self.row_positions) and c2 < len(self.col_positions):
                 self.create_selection_box(r1, c1, r2, c2, v, run_binding=True)
         if selected:
-            self.set_currently_selected(selected.row, selected.column, box=selected.coords)
+            self.set_currently_selected(selected.row, selected.column, box=selected.box)
 
     def set_currently_selected(
         self,
@@ -5750,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:
@@ -5776,7 +5843,7 @@ class MainTable(tk.Canvas):
             self.hidd_boxes.add(item)
             self.itemconfig(item, state="hidden")
 
-    def hide_selection_box(self, item: int | None, set_current: bool = True) -> None:
+    def hide_selection_box(self, item: int | None, set_current: bool = True) -> bool:
         if item is None:
             return
         box = self.selection_boxes.pop(item)
@@ -5787,6 +5854,7 @@ class MainTable(tk.Canvas):
         if self.selected.fill_iid == item:
             self.hide_selected()
             self.set_current_to_last()
+        return True
 
     def hide_selected(self) -> None:
         if self.selected:
@@ -5819,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,
@@ -5858,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",
@@ -5904,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,
@@ -5926,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:
@@ -6032,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")
@@ -6372,13 +6447,11 @@ class MainTable(tk.Canvas):
                     extra_func_key = "Return"
                 elif hasattr(event, "keysym") and event.keysym == "F2":
                     extra_func_key = "F2"
-            datarn = r if self.all_rows_displayed else self.displayed_rows[r]
-            datacn = c if self.all_columns_displayed else self.displayed_columns[c]
             if event is not None and (hasattr(event, "keysym") and event.keysym == "BackSpace"):
                 extra_func_key = "BackSpace"
                 text = ""
             else:
-                text = f"{self.get_cell_data(datarn, datacn, none_to_empty_str = True)}"
+                text = f"{self.get_cell_data(self.datarn(r), self.datacn(c), none_to_empty_str = True)}"
         elif event is not None and (
             (hasattr(event, "char") and event.char.isalpha())
             or (hasattr(event, "char") and event.char.isdigit())
@@ -6422,9 +6495,7 @@ class MainTable(tk.Canvas):
         w = self.col_positions[c + 1] - x + 1
         h = self.row_positions[r + 1] - y + 1
         if text is None:
-            text = f"""{self.get_cell_data(r if self.all_rows_displayed else self.displayed_rows[r],
-                                           c if self.all_columns_displayed else self.displayed_columns[c],
-                                           none_to_empty_str = True)}"""
+            text = f"{self.get_cell_data(self.datarn(r), self.datacn(c), none_to_empty_str = True)}"
         bg, fg = self.PAR.ops.table_bg, self.PAR.ops.table_fg
         kwargs = {
             "menu_kwargs": DotDict(
@@ -6483,7 +6554,14 @@ class MainTable(tk.Canvas):
         curr_height = self.text_editor.window.winfo_height()
         if curr_height < self.min_row_height:
             return
-        if not check_lines or self.get_lines_cell_height(self.text_editor.window.get_num_lines() + 1) > curr_height:
+        if (
+            not check_lines
+            or self.get_lines_cell_height(
+                self.text_editor.window.get_num_lines() + 1,
+                font=self.text_editor.tktext.cget("font"),
+            )
+            > curr_height
+        ):
             new_height = curr_height + self.table_xtra_lines_increment
             space_bot = self.get_space_bot(r)
             if new_height > space_bot:
@@ -6508,24 +6586,30 @@ class MainTable(tk.Canvas):
                         )
                         self.itemconfig(self.dropdown.canvas_id, anchor=anchor, height=win_h)
 
-    def refresh_open_window_positions(self):
+    def refresh_open_window_positions(self, zoom: Literal["in", "out"]):
         if self.text_editor.open:
             r, c = self.text_editor.coords
             self.text_editor.window.config(height=self.row_positions[r + 1] - self.row_positions[r])
+            self.text_editor.tktext.config(font=self.PAR.ops.table_font)
             self.coords(
                 self.text_editor.canvas_id,
                 self.col_positions[c],
                 self.row_positions[r],
             )
         if self.dropdown.open:
+            if zoom == "in":
+                self.dropdown.window.zoom_in()
+            elif zoom == "out":
+                self.dropdown.window.zoom_out()
             r, c = self.dropdown.get_coords()
             if self.text_editor.open:
                 text_editor_h = self.text_editor.window.winfo_height()
                 win_h, anchor = self.get_dropdown_height_anchor(r, c, text_editor_h)
             else:
-                text_editor_h = self.row_positions[r + 1] - self.row_positions[r]
+                text_editor_h = self.row_positions[r + 1] - self.row_positions[r] + 1
                 anchor = self.itemcget(self.dropdown.canvas_id, "anchor")
                 # win_h = 0
+            self.dropdown.window.config(width=self.col_positions[c + 1] - self.col_positions[c] + 1)
             if anchor == "nw":
                 self.coords(
                     self.dropdown.canvas_id,
@@ -6543,12 +6627,13 @@ 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":
             self.focus_set()
 
-    # c is displayed col
     def close_text_editor(
         self,
         editor_info: tuple | None = None,
@@ -6566,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,
@@ -6590,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 (
@@ -6604,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
@@ -6671,8 +6756,7 @@ class MainTable(tk.Canvas):
     def tab_key(self, event: object = None) -> str:
         if not self.selected:
             return
-        r = self.selected.row
-        c = self.selected.column
+        r, c = self.selected.row, self.selected.column
         r1, c1, r2, c2 = self.selection_boxes[self.selected.fill_iid].coords
         numcols = c2 - c1
         numrows = r2 - r1
@@ -6803,7 +6887,7 @@ class MainTable(tk.Canvas):
         }
         if self.dropdown.window:
             self.dropdown.window.reset(**reset_kwargs)
-            self.itemconfig(self.dropdown.canvas_id, state="normal")
+            self.itemconfig(self.dropdown.canvas_id, state="normal", anchor=anchor)
             self.coords(self.dropdown.canvas_id, self.col_positions[c], ypos)
         else:
             self.dropdown.window = self.PAR.dropdown_class(
@@ -6923,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
 
@@ -6974,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:
@@ -7100,7 +7187,12 @@ class MainTable(tk.Canvas):
         self.delete_row_format("all", clear_values=clear_values)
         self.delete_column_format("all", clear_values=clear_values)
 
-    def delete_cell_format(self, datarn: str | int = "all", datacn: int = 0, clear_values: bool = False) -> None:
+    def delete_cell_format(
+        self,
+        datarn: Literal["all"] | int = "all",
+        datacn: int = 0,
+        clear_values: bool = False,
+    ) -> None:
         if isinstance(datarn, str) and datarn.lower() == "all":
             itr = gen_formatted(self.cell_options)
         else:
@@ -7114,7 +7206,7 @@ class MainTable(tk.Canvas):
             if clear_values:
                 self.set_cell_data(*key, get_val(*key), expand_sheet=False)
 
-    def delete_row_format(self, datarn: str | int = "all", clear_values: bool = False) -> None:
+    def delete_row_format(self, datarn: Literal["all"] | int = "all", clear_values: bool = False) -> None:
         if isinstance(datarn, str) and datarn.lower() == "all":
             itr = gen_formatted(self.row_options)
         else:
@@ -7129,7 +7221,7 @@ class MainTable(tk.Canvas):
                 for datacn in range(len(self.data[datarn])):
                     self.set_cell_data(datarn, datacn, get_val(datarn, datacn), expand_sheet=False)
 
-    def delete_column_format(self, datacn: str | int = "all", clear_values: bool = False) -> None:
+    def delete_column_format(self, datacn: Literal["all"] | int = "all", clear_values: bool = False) -> None:
         if isinstance(datacn, str) and datacn.lower() == "all":
             itr = gen_formatted(self.col_options)
         else: