tksheet 7.3.3__py3-none-any.whl → 7.4.0__py3-none-any.whl

tksheet/column_headers.py

@@ -2,29 +2,17 @@ from __future__ import annotations
 
 import tkinter as tk
 from collections import defaultdict
-from collections.abc import (
-    Hashable,
-    Sequence,
-)
-from functools import (
-    partial,
-)
-from itertools import (
-    cycle,
-    islice,
-    repeat,
-)
+from collections.abc import Callable, Hashable, Sequence
+from functools import partial
+from itertools import cycle, islice, repeat
 from math import ceil, floor
-from operator import (
-    itemgetter,
-)
+from operator import itemgetter
 from typing import Literal
 
-from .colors import (
-    color_map,
-)
+from .colors import color_map
 from .constants import (
     USER_OS,
+    _test_str,
     rc_binding,
     text_editor_close_bindings,
     text_editor_newline_bindings,
@@ -39,36 +27,33 @@ from .functions import (
     get_n2a,
     int_x_tuple,
     is_contiguous,
+    mod_event_val,
     new_tk_event,
     rounded_box_coords,
     stored_event_dict,
+    try_b_index,
     try_binding,
+    wrap_text,
 )
-from .other_classes import (
-    DotDict,
-    DraggedRowColumn,
-    DropdownStorage,
-    TextEditorStorage,
-)
-from .text_editor import (
-    TextEditor,
-)
-from .types import (
-    AnyIter,
-)
+from .other_classes import DotDict, DraggedRowColumn, DropdownStorage, EventDataDict, TextEditorStorage
+from .row_index import RowIndex
+from .sorting import sort_column, sort_rows_by_column, sort_tree_view
+from .text_editor import TextEditor
+from .tksheet_types import AnyIter
 
 
 class ColumnHeaders(tk.Canvas):
-    def __init__(self, *args, **kwargs):
+    def __init__(self, parent, **kwargs):
         super().__init__(
-            kwargs["parent"],
-            background=kwargs["parent"].ops.header_bg,
+            parent,
+            background=parent.ops.header_bg,
             highlightthickness=0,
         )
-        self.PAR = kwargs["parent"]
+        self.PAR = parent
+        self.ops = self.PAR.ops
         self.current_height = None
         self.MT = None  # is set from within MainTable() __init__
-        self.RI = None  # is set from within MainTable() __init__
+        self.RI: RowIndex | None = None  # is set from within MainTable() __init__
         self.TL = None  # is set from within TopLeftRectangle() __init__
         self.popup_menu_loc = None
         self.extra_begin_edit_cell_func = None
@@ -85,6 +70,8 @@ class ColumnHeaders(tk.Canvas):
         self.extra_double_b1_func = None
         self.ch_extra_begin_drag_drop_func = None
         self.ch_extra_end_drag_drop_func = None
+        self.ch_extra_begin_sort_rows_func = None
+        self.ch_extra_end_sort_rows_func = None
         self.extra_rc_func = None
         self.selection_binding_func = None
         self.shift_selection_binding_func = None
@@ -164,36 +151,8 @@ class ColumnHeaders(tk.Canvas):
                 self.unbind("<Button-4>")
                 self.unbind("<Button-5>")
 
-    def mousewheel(self, event: object) -> None:
-        if isinstance(self.MT._headers, int):
-            maxlines = max(
-                (
-                    len(
-                        self.MT.get_valid_cell_data_as_str(self.MT._headers, datacn, get_displayed=True)
-                        .rstrip()
-                        .split("\n")
-                    )
-                    for datacn in range(len(self.MT.data[self.MT._headers]))
-                ),
-                default=0,
-            )
-        elif isinstance(self.MT._headers, (list, tuple)):
-            maxlines = max(
-                (
-                    len(e.rstrip().split("\n")) if isinstance(e, str) else len(f"{e}".rstrip().split("\n"))
-                    for e in self.MT._headers
-                ),
-                default=0,
-            )
-        if maxlines == 1:
-            maxlines = 0
-        if self.lines_start_at > maxlines:
-            self.lines_start_at = maxlines
-        if (event.delta < 0 or event.num == 5) and self.lines_start_at < maxlines:
-            self.lines_start_at += 1
-        elif (event.delta >= 0 or event.num == 4) and self.lines_start_at > 0:
-            self.lines_start_at -= 1
-        self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=False, redraw_table=False)
+    def mousewheel(self, event: tk.Event) -> None:
+        self.MT.mousewheel(event)
 
     def set_height(self, new_height: int, set_TL: bool = False) -> bool:
         try:
@@ -463,20 +422,22 @@ class ColumnHeaders(tk.Canvas):
                 x,
                 self.current_height,
                 width=1,
-                fill=self.PAR.ops.resizing_line_fg,
-                tag="rwl",
+                fill=self.ops.resizing_line_fg,
+                tag=("rw", "rwl"),
             )
-            self.MT.create_resize_line(x, y1, x, y2, width=1, fill=self.PAR.ops.resizing_line_fg, tag="rwl")
+            self.MT.create_resize_line(x, y1, x, y2, width=1, fill=self.ops.resizing_line_fg, tag=("rw", "rwl"))
             self.create_resize_line(
                 line2x,
                 0,
                 line2x,
                 self.current_height,
                 width=1,
-                fill=self.PAR.ops.resizing_line_fg,
-                tag="rwl2",
+                fill=self.ops.resizing_line_fg,
+                tag=("rw", "rwl2"),
+            )
+            self.MT.create_resize_line(
+                line2x, y1, line2x, y2, width=1, fill=self.ops.resizing_line_fg, tag=("rw", "rwl2")
             )
-            self.MT.create_resize_line(line2x, y1, line2x, y2, width=1, fill=self.PAR.ops.resizing_line_fg, tag="rwl2")
         elif self.height_resizing_enabled and self.rsz_w is None and self.rsz_h is not None:
             self.currently_resizing_height = True
         elif self.MT.identify_col(x=event.x, allow_end=False) is None:
@@ -506,7 +467,7 @@ class ColumnHeaders(tk.Canvas):
         if self.width_resizing_enabled and self.rsz_w is not None and self.currently_resizing_width:
             x = self.canvasx(event.x)
             size = x - self.MT.col_positions[self.rsz_w - 1]
-            if size >= self.PAR.ops.min_column_width and size < self.PAR.ops.max_column_width:
+            if size >= self.ops.min_column_width and size < self.ops.max_column_width:
                 self.hide_resize_and_ctrl_lines(ctrl_lines=False)
                 line2x = self.MT.col_positions[self.rsz_w - 1]
                 self.create_resize_line(
@@ -515,18 +476,18 @@ class ColumnHeaders(tk.Canvas):
                     x,
                     self.current_height,
                     width=1,
-                    fill=self.PAR.ops.resizing_line_fg,
-                    tag="rwl",
+                    fill=self.ops.resizing_line_fg,
+                    tag=("rw", "rwl"),
                 )
-                self.MT.create_resize_line(x, y1, x, y2, width=1, fill=self.PAR.ops.resizing_line_fg, tag="rwl")
+                self.MT.create_resize_line(x, y1, x, y2, width=1, fill=self.ops.resizing_line_fg, tag=("rw", "rwl"))
                 self.create_resize_line(
                     line2x,
                     0,
                     line2x,
                     self.current_height,
                     width=1,
-                    fill=self.PAR.ops.resizing_line_fg,
-                    tag="rwl2",
+                    fill=self.ops.resizing_line_fg,
+                    tag=("rw", "rwl2"),
                 )
                 self.MT.create_resize_line(
                     line2x,
@@ -534,15 +495,15 @@ class ColumnHeaders(tk.Canvas):
                     line2x,
                     y2,
                     width=1,
-                    fill=self.PAR.ops.resizing_line_fg,
-                    tag="rwl2",
+                    fill=self.ops.resizing_line_fg,
+                    tag=("rw", "rwl2"),
                 )
                 self.drag_width_resize()
         elif self.height_resizing_enabled and self.rsz_h is not None and self.currently_resizing_height:
             evy = event.y
             if evy > self.current_height:
-                if evy > self.PAR.ops.max_header_height:
-                    evy = int(self.PAR.ops.max_header_height)
+                if evy > self.ops.max_header_height:
+                    evy = int(self.ops.max_header_height)
                 self.drag_height_resize(evy)
             else:
                 if evy < self.MT.min_header_height:
@@ -707,16 +668,16 @@ class ColumnHeaders(tk.Canvas):
             xpos,
             self.current_height,
             width=3,
-            fill=self.PAR.ops.drag_and_drop_bg,
+            fill=self.ops.drag_and_drop_bg,
             tag="move_columns",
         )
-        self.MT.create_resize_line(xpos, y1, xpos, y2, width=3, fill=self.PAR.ops.drag_and_drop_bg, tag="move_columns")
+        self.MT.create_resize_line(xpos, y1, xpos, y2, width=3, fill=self.ops.drag_and_drop_bg, tag="move_columns")
         for boxst, boxend in consecutive_ranges(cols):
             self.MT.show_ctrl_outline(
                 start_cell=(boxst, 0),
                 end_cell=(boxend, len(self.MT.row_positions) - 1),
                 dash=(),
-                outline=self.PAR.ops.drag_and_drop_bg,
+                outline=self.ops.drag_and_drop_bg,
                 delete_on_timer=False,
             )
 
@@ -779,10 +740,10 @@ class ColumnHeaders(tk.Canvas):
         new_col_pos = int(self.coords("rwl")[0])
         old_width = self.MT.col_positions[self.rsz_w] - self.MT.col_positions[self.rsz_w - 1]
         size = new_col_pos - self.MT.col_positions[self.rsz_w - 1]
-        if size < self.PAR.ops.min_column_width:
-            new_col_pos = ceil(self.MT.col_positions[self.rsz_w - 1] + self.PAR.ops.min_column_width)
-        elif size > self.PAR.ops.max_column_width:
-            new_col_pos = floor(self.MT.col_positions[self.rsz_w - 1] + self.PAR.ops.max_column_width)
+        if size < self.ops.min_column_width:
+            new_col_pos = ceil(self.MT.col_positions[self.rsz_w - 1] + self.ops.min_column_width)
+        elif size > self.ops.max_column_width:
+            new_col_pos = floor(self.MT.col_positions[self.rsz_w - 1] + self.ops.max_column_width)
         increment = new_col_pos - self.MT.col_positions[self.rsz_w]
         self.MT.col_positions[self.rsz_w + 1 :] = [
             e + increment for e in islice(self.MT.col_positions, self.rsz_w + 1, None)
@@ -791,7 +752,7 @@ class ColumnHeaders(tk.Canvas):
         new_width = self.MT.col_positions[self.rsz_w] - self.MT.col_positions[self.rsz_w - 1]
         self.MT.allow_auto_resize_columns = False
         self.MT.recreate_all_selection_boxes()
-        self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
+        self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True, set_scrollregion=False)
         if self.column_width_resize_func is not None and old_width != new_width:
             self.column_width_resize_func(
                 event_dict(
@@ -816,8 +777,8 @@ class ColumnHeaders(tk.Canvas):
         self.MT.bind("<MouseWheel>", self.MT.mousewheel)
         if self.width_resizing_enabled and self.rsz_w is not None and self.currently_resizing_width:
             self.drag_width_resize()
-            self.currently_resizing_width = False
             self.hide_resize_and_ctrl_lines(ctrl_lines=False)
+            self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
         elif (
             self.drag_and_drop_enabled
             and self.col_selection_enabled
@@ -843,22 +804,16 @@ class ColumnHeaders(tk.Canvas):
                     c += 1
                 if c > len(self.MT.col_positions) - 1:
                     c = len(self.MT.col_positions) - 1
-                event_data = event_dict(
-                    name="move_columns",
-                    sheet=self.PAR.name,
-                    widget=self,
-                    boxes=self.MT.get_boxes(),
-                    selected=self.MT.selected,
-                    value=c,
-                )
+                event_data = self.MT.new_event_dict("move_columns", state=True)
+                event_data["value"] = c
                 if try_binding(self.ch_extra_begin_drag_drop_func, event_data, "begin_move_columns"):
                     data_new_idxs, disp_new_idxs, event_data = self.MT.move_columns_adjust_options_dict(
                         *self.MT.get_args_for_move_columns(
                             move_to=c,
                             to_move=self.dragged_col.to_move,
                         ),
-                        move_data=self.PAR.ops.column_drag_and_drop_perform,
-                        move_widths=self.PAR.ops.column_drag_and_drop_perform,
+                        move_data=self.ops.column_drag_and_drop_perform,
+                        move_widths=self.ops.column_drag_and_drop_perform,
                         event_data=event_data,
                     )
                     event_data["moved"]["columns"] = {
@@ -904,6 +859,126 @@ class ColumnHeaders(tk.Canvas):
         self.mouse_motion(event)
         try_binding(self.extra_b1_release_func, event)
 
+    def _sort_columns(
+        self,
+        event: tk.Event | None = None,
+        columns: AnyIter[int] | None = None,
+        reverse: bool = False,
+        validation: bool = True,
+        key: Callable | None = None,
+        undo: bool = True,
+    ) -> EventDataDict:
+        if columns is None:
+            columns = self.MT.get_selected_cols()
+        if not columns:
+            columns = list(range(0, len(self.MT.col_positions) - 1))
+        event_data = self.MT.new_event_dict("edit_table")
+        try_binding(self.MT.extra_begin_sort_cells_func, event_data)
+        for c in columns:
+            datacn = self.MT.datacn(c)
+            for r, val in enumerate(
+                sort_column(
+                    (self.MT.get_cell_data(row, datacn) for row in range(len(self.MT.data))),
+                    reverse=reverse,
+                    key=key,
+                )
+            ):
+                if (
+                    not self.MT.edit_validation_func
+                    or not validation
+                    or (
+                        self.MT.edit_validation_func
+                        and (val := self.MT.edit_validation_func(mod_event_val(event_data, val, (r, datacn))))
+                        is not None
+                    )
+                ):
+                    event_data = self.MT.event_data_set_cell(
+                        datarn=r,
+                        datacn=datacn,
+                        value=val,
+                        event_data=event_data,
+                    )
+        if event_data["cells"]["table"]:
+            if undo and self.MT.undo_enabled:
+                self.MT.undo_stack.append(stored_event_dict(event_data))
+            try_binding(self.MT.extra_end_sort_cells_func, event_data, "end_edit_table")
+            self.MT.sheet_modified(event_data)
+            self.PAR.emit_event("<<SheetModified>>", event_data)
+            self.MT.refresh()
+        return event_data
+
+    def _sort_rows_by_column(
+        self,
+        event: tk.Event | None = None,
+        column: int | None = None,
+        reverse: bool = False,
+        key: Callable | None = None,
+        undo: bool = True,
+    ) -> EventDataDict:
+        event_data = self.MT.new_event_dict("sort_rows", state=True)
+        if not self.MT.data:
+            return event_data
+        if column is None:
+            if not self.MT.selected:
+                return event_data
+            column = self.MT.selected.column
+        if try_binding(self.ch_extra_begin_sort_rows_func, event_data, "begin_sort_rows"):
+            disp_new_idxs, disp_row_ctr = {}, 0
+            if self.ops.treeview:
+                new_nodes_order, data_new_idxs = sort_tree_view(
+                    _row_index=self.MT._row_index,
+                    tree_rns=self.RI.tree_rns,
+                    tree=self.RI.tree,
+                    key=key,
+                    reverse=reverse,
+                )
+                for node in new_nodes_order:
+                    if (idx := try_b_index(self.MT.displayed_rows, self.RI.tree_rns[node.iid])) is not None:
+                        disp_new_idxs[idx] = disp_row_ctr
+                        disp_row_ctr += 1
+            else:
+                new_rows_order, data_new_idxs = sort_rows_by_column(
+                    self.MT.data, column=column, reverse=reverse, key=key
+                )
+                if self.MT.all_rows_displayed:
+                    disp_new_idxs = data_new_idxs
+                else:
+                    for old_idx, _ in new_rows_order:
+                        if (idx := try_b_index(self.MT.displayed_rows, old_idx)) is not None:
+                            disp_new_idxs[idx] = disp_row_ctr
+                            disp_row_ctr += 1
+            if self.PAR.ops.treeview:
+                data_new_idxs, disp_new_idxs, event_data = self.MT.move_rows_adjust_options_dict(
+                    data_new_idxs=data_new_idxs,
+                    data_old_idxs=dict(zip(data_new_idxs.values(), data_new_idxs)),
+                    totalrows=None,
+                    disp_new_idxs=disp_new_idxs,
+                    move_data=True,
+                    create_selections=False,
+                    event_data=event_data,
+                )
+            else:
+                data_new_idxs, disp_new_idxs, _ = self.PAR.mapping_move_rows(
+                    data_new_idxs=data_new_idxs,
+                    disp_new_idxs=disp_new_idxs,
+                    move_data=True,
+                    create_selections=False,
+                    undo=False,
+                    emit_event=False,
+                    redraw=True,
+                )
+            event_data["moved"]["rows"] = {
+                "data": data_new_idxs,
+                "displayed": disp_new_idxs,
+            }
+            if undo and self.MT.undo_enabled:
+                self.MT.undo_stack.append(stored_event_dict(event_data))
+            try_binding(self.ch_extra_end_sort_rows_func, event_data, "end_sort_rows")
+            self.MT.sheet_modified(event_data)
+            self.PAR.emit_event("<<SheetModified>>", event_data)
+            self.MT.refresh()
+        return event_data
+
     def toggle_select_col(
         self,
         column: int,
@@ -992,7 +1067,7 @@ class ColumnHeaders(tk.Canvas):
             y1,
             x2,
             y2,
-            radius=5 if self.PAR.ops.rounded_boxes else 0,
+            radius=5 if self.ops.rounded_boxes else 0,
         )
         if isinstance(iid, int):
             self.coords(iid, coords)
@@ -1019,13 +1094,13 @@ class ColumnHeaders(tk.Canvas):
             self.MT.txt_measure_canvas.itemconfig(
                 self.MT.txt_measure_canvas_text,
                 text=txt,
-                font=self.PAR.ops.header_font,
+                font=self.ops.header_font,
             )
             b = self.MT.txt_measure_canvas.bbox(self.MT.txt_measure_canvas_text)
             w = b[2] - b[0] + 7
             h = b[3] - b[1] + 5
         else:
-            w = self.PAR.ops.min_column_width
+            w = self.ops.min_column_width
             h = self.MT.min_header_height
         if datacn in self.cell_options and (
             self.get_cell_kwargs(datacn, key="dropdown") or self.get_cell_kwargs(datacn, key="checkbox")
@@ -1047,7 +1122,7 @@ class ColumnHeaders(tk.Canvas):
         qconf = self.MT.txt_measure_canvas.itemconfig
         qbbox = self.MT.txt_measure_canvas.bbox
         qtxtm = self.MT.txt_measure_canvas_text
-        qfont = self.PAR.ops.header_font
+        qfont = self.ops.header_font
         default_header_height = self.MT.get_default_header_height()
         if text is not None and text:
             qconf(qtxtm, text=text, font=qfont)
@@ -1083,8 +1158,8 @@ class ColumnHeaders(tk.Canvas):
             h = space_bot
         if h < self.MT.min_header_height:
             h = int(self.MT.min_header_height)
-        elif h > self.PAR.ops.max_header_height:
-            h = int(self.PAR.ops.max_header_height)
+        elif h > self.ops.max_header_height:
+            h = int(self.ops.max_header_height)
         if not only_if_too_small or (only_if_too_small and h > self.current_height):
             self.set_height(h, set_TL=True)
             self.MT.main_table_redraw_grid_and_text(redraw_header=True, redraw_row_index=True)
@@ -1097,7 +1172,7 @@ class ColumnHeaders(tk.Canvas):
         only_if_too_small: bool = False,
     ) -> int:
         self.fix_header()
-        w = self.PAR.ops.min_column_width
+        w = self.ops.min_column_width
         datacn = col if self.MT.all_columns_displayed else self.MT.displayed_columns[col]
         # header
         hw, hh_ = self.get_cell_dimensions(datacn)
@@ -1118,7 +1193,7 @@ class ColumnHeaders(tk.Canvas):
             qbbox = self.MT.txt_measure_canvas.bbox
             qtxtm = self.MT.txt_measure_canvas_text
             qtxth = self.MT.table_txt_height
-            qfont = self.PAR.ops.table_font
+            qfont = self.ops.table_font
             for datarn in iterable:
                 if txt := self.MT.get_valid_cell_data_as_str(datarn, datacn, get_displayed=True):
                     qconf(qtxtm, text=txt, font=qfont)
@@ -1134,10 +1209,10 @@ class ColumnHeaders(tk.Canvas):
             w = hw
         if only_if_too_small and w < self.MT.col_positions[col + 1] - self.MT.col_positions[col]:
             w = self.MT.col_positions[col + 1] - self.MT.col_positions[col]
-        if w <= self.PAR.ops.min_column_width:
-            w = self.PAR.ops.min_column_width
-        elif w > self.PAR.ops.max_column_width:
-            w = int(self.PAR.ops.max_column_width)
+        if w <= self.ops.min_column_width:
+            w = self.ops.min_column_width
+        elif w > self.ops.max_column_width:
+            w = int(self.ops.max_column_width)
         return w
 
     def set_col_width(
@@ -1150,10 +1225,10 @@ class ColumnHeaders(tk.Canvas):
     ) -> int:
         if width is None:
             width = self.get_col_text_width(col=col, visible_only=visible_only)
-        if width <= self.PAR.ops.min_column_width:
-            width = self.PAR.ops.min_column_width
-        elif width > self.PAR.ops.max_column_width:
-            width = int(self.PAR.ops.max_column_width)
+        if width <= self.ops.min_column_width:
+            width = self.ops.min_column_width
+        elif width > self.ops.max_column_width:
+            width = int(self.ops.max_column_width)
         if only_if_too_small and width <= self.MT.col_positions[col + 1] - self.MT.col_positions[col]:
             return self.MT.col_positions[col + 1] - self.MT.col_positions[col]
         new_col_pos = self.MT.col_positions[col] + width
@@ -1206,8 +1281,8 @@ class ColumnHeaders(tk.Canvas):
                 fill = color_map[fill]
             if "columns" in selections and c in selections["columns"]:
                 txtfg = (
-                    self.PAR.ops.header_selected_columns_fg
-                    if kwargs[1] is None or self.PAR.ops.display_selected_fg_over_highlights
+                    self.ops.header_selected_columns_fg
+                    if kwargs[1] is None or self.ops.display_selected_fg_over_highlights
                     else kwargs[1]
                 )
                 if fill:
@@ -1218,8 +1293,8 @@ class ColumnHeaders(tk.Canvas):
                     )
             elif "cells" in selections and c in selections["cells"]:
                 txtfg = (
-                    self.PAR.ops.header_selected_cells_fg
-                    if kwargs[1] is None or self.PAR.ops.display_selected_fg_over_highlights
+                    self.ops.header_selected_cells_fg
+                    if kwargs[1] is None or self.ops.display_selected_fg_over_highlights
                     else kwargs[1]
                 )
                 if fill:
@@ -1229,7 +1304,7 @@ class ColumnHeaders(tk.Canvas):
                         + f"{int((int(fill[5:], 16) + int(sel_cells_bg[5:], 16)) / 2):02X}"
                     )
             else:
-                txtfg = self.PAR.ops.header_fg if kwargs[1] is None else kwargs[1]
+                txtfg = self.ops.header_fg if kwargs[1] is None else kwargs[1]
             if fill:
                 redrawn = self.redraw_highlight(
                     fc + 1,
@@ -1238,19 +1313,19 @@ class ColumnHeaders(tk.Canvas):
                     self.current_height - 1,
                     fill=fill,
                     outline=(
-                        self.PAR.ops.header_fg
-                        if self.get_cell_kwargs(datacn, key="dropdown") and self.PAR.ops.show_dropdown_borders
+                        self.ops.header_fg
+                        if self.get_cell_kwargs(datacn, key="dropdown") and self.ops.show_dropdown_borders
                         else ""
                     ),
                     tag="hi",
                 )
         elif not kwargs:
             if "columns" in selections and c in selections["columns"]:
-                txtfg = self.PAR.ops.header_selected_columns_fg
+                txtfg = self.ops.header_selected_columns_fg
             elif "cells" in selections and c in selections["cells"]:
-                txtfg = self.PAR.ops.header_selected_cells_fg
+                txtfg = self.ops.header_selected_cells_fg
             else:
-                txtfg = self.PAR.ops.header_fg
+                txtfg = self.ops.header_fg
         return txtfg, redrawn
 
     def redraw_highlight(
@@ -1271,6 +1346,7 @@ class ColumnHeaders(tk.Canvas):
                 self.itemconfig(iid, fill=fill, outline=outline)
             else:
                 self.itemconfig(iid, fill=fill, outline=outline, tag=tag, state="normal")
+            self.tag_raise(iid)
         else:
             iid = self.create_rectangle(coords, fill=fill, outline=outline, tag=tag)
         self.disp_high[iid] = True
@@ -1291,6 +1367,7 @@ class ColumnHeaders(tk.Canvas):
             else:
                 self.itemconfig(t, fill=fill, width=width, tag=tag, state="normal")
             self.disp_grid[t] = True
+            self.tag_raise(t)
         else:
             self.disp_grid[self.create_line(points, fill=fill, width=width, tag=tag)] = True
 
@@ -1307,8 +1384,8 @@ class ColumnHeaders(tk.Canvas):
         draw_arrow: bool = True,
         open_: bool = False,
     ) -> None:
-        if draw_outline and self.PAR.ops.show_dropdown_borders:
-            self.redraw_highlight(x1 + 1, y1 + 1, x2, y2, fill="", outline=self.PAR.ops.header_fg, tag=tag)
+        if draw_outline and self.ops.show_dropdown_borders:
+            self.redraw_highlight(x1 + 1, y1 + 1, x2, y2, fill="", outline=self.ops.header_fg, tag=tag)
         if draw_arrow:
             mod = (self.MT.header_txt_height - 1) if self.MT.header_txt_height % 2 else self.MT.header_txt_height
             small_mod = int(mod / 5)
@@ -1394,15 +1471,33 @@ class ColumnHeaders(tk.Canvas):
                 t = self.create_polygon(points, fill=fill, outline=outline, tag=tag, smooth=True)
             self.disp_checkbox[t] = True
 
-    def configure_scrollregion(self, last_col_line_pos: float) -> None:
-        self.configure(
-            scrollregion=(
-                0,
-                0,
-                last_col_line_pos + self.PAR.ops.empty_horizontal + 2,
-                self.current_height,
+    def configure_scrollregion(self, last_col_line_pos: float) -> bool:
+        try:
+            self.configure(
+                scrollregion=(
+                    0,
+                    0,
+                    last_col_line_pos + self.ops.empty_horizontal + 2,
+                    self.current_height,
+                )
             )
+            return True
+        except Exception:
+            return False
+
+    def wrap_get_char_w(self, c: str) -> int:
+        self.MT.txt_measure_canvas.itemconfig(
+            self.MT.txt_measure_canvas_text,
+            text=_test_str + c,
+            font=self.header_font,
         )
+        b = self.MT.txt_measure_canvas.bbox(self.MT.txt_measure_canvas_text)
+        if c in self.MT.char_widths[self.header_font]:
+            return self.MT.char_widths[self.header_font][c]
+        else:
+            wd = b[2] - b[0] - self.header_test_str_w
+            self.MT.char_widths[self.header_font][c] = wd
+            return wd
 
     def redraw_grid_and_text(
         self,
@@ -1415,11 +1510,11 @@ class ColumnHeaders(tk.Canvas):
         text_end_col: int,
         scrollpos_right: float,
         col_pos_exists: bool,
+        set_scrollregion: bool,
     ) -> bool:
-        try:
-            self.configure_scrollregion(last_col_line_pos=last_col_line_pos)
-        except Exception:
-            return False
+        if set_scrollregion:
+            if not self.configure_scrollregion(last_col_line_pos=last_col_line_pos):
+                return False
         self.hidd_text.update(self.disp_text)
         self.disp_text = {}
         self.hidd_high.update(self.disp_high)
@@ -1437,49 +1532,24 @@ class ColumnHeaders(tk.Canvas):
             x_stop,
             self.current_height,
         )
-        yend = self.current_height - 5
-        if (self.PAR.ops.show_vertical_grid or self.width_resizing_enabled) and col_pos_exists:
-            points = [
-                x_stop - 1,
-                self.current_height - 1,
-                scrollpos_left - 1,
-                self.current_height - 1,
-                scrollpos_left - 1,
-                -1,
-            ]
-            for c in range(grid_start_col, grid_end_col):
-                draw_x = self.MT.col_positions[c]
-                if c and self.width_resizing_enabled:
-                    self.visible_col_dividers[c] = (draw_x - 2, 1, draw_x + 2, yend)
-                points.extend(
-                    (
-                        draw_x,
-                        -1,
-                        draw_x,
-                        self.current_height,
-                        draw_x,
-                        -1,
-                        self.MT.col_positions[c + 1] if len(self.MT.col_positions) - 1 > c else draw_x,
-                        -1,
-                    )
-                )
-            self.redraw_gridline(points=points, fill=self.PAR.ops.header_grid_fg, width=1, tag="v")
         top = self.canvasy(0)
         sel_cols_bg = (
-            self.PAR.ops.header_selected_cells_bg
-            if self.PAR.ops.header_selected_cells_bg.startswith("#")
-            else color_map[self.PAR.ops.header_selected_cells_bg]
+            self.ops.header_selected_cells_bg
+            if self.ops.header_selected_cells_bg.startswith("#")
+            else color_map[self.ops.header_selected_cells_bg]
         )
         sel_cells_bg = (
-            self.PAR.ops.header_selected_columns_bg
-            if self.PAR.ops.header_selected_columns_bg.startswith("#")
-            else color_map[self.PAR.ops.header_selected_columns_bg]
+            self.ops.header_selected_columns_bg
+            if self.ops.header_selected_columns_bg.startswith("#")
+            else color_map[self.ops.header_selected_columns_bg]
         )
-        font = self.PAR.ops.header_font
+        font = self.ops.header_font
         selections = self.get_redraw_selections(text_start_col, grid_end_col)
         dd_coords = self.dropdown.get_coords()
+        wrap = self.ops.header_wrap
+        txt_h = self.MT.header_txt_height
         for c in range(text_start_col, text_end_col):
-            draw_y = self.MT.header_first_ln_ins
+            draw_y = 3
             cleftgridln = self.MT.col_positions[c]
             crightgridln = self.MT.col_positions[c + 1]
             datacn = c if self.MT.all_columns_displayed else self.MT.displayed_columns[c]
@@ -1492,80 +1562,45 @@ class ColumnHeaders(tk.Canvas):
                 selections=selections,
                 datacn=datacn,
             )
-
             if datacn in self.cell_options and "align" in self.cell_options[datacn]:
                 align = self.cell_options[datacn]["align"]
             else:
                 align = self.align
-
-            kwargs = self.get_cell_kwargs(datacn, key="dropdown")
-            if align == "w":
-                draw_x = cleftgridln + 3
-                if kwargs:
-                    mw = crightgridln - cleftgridln - self.MT.header_txt_height - 2
-                    self.redraw_dropdown(
-                        cleftgridln,
-                        0,
-                        crightgridln,
-                        self.current_height - 1,
-                        fill=fill if kwargs["state"] != "disabled" else self.PAR.ops.header_grid_fg,
-                        outline=fill,
-                        tag="dd",
-                        draw_outline=not dd_drawn,
-                        draw_arrow=mw >= 5,
-                        open_=dd_coords == c,
-                    )
-                else:
-                    mw = crightgridln - cleftgridln - 1
-
-            elif align == "e":
-                if kwargs:
-                    mw = crightgridln - cleftgridln - self.MT.header_txt_height - 2
-                    draw_x = crightgridln - 5 - self.MT.header_txt_height
-                    self.redraw_dropdown(
-                        cleftgridln,
-                        0,
-                        crightgridln,
-                        self.current_height - 1,
-                        fill=fill if kwargs["state"] != "disabled" else self.PAR.ops.header_grid_fg,
-                        outline=fill,
-                        tag="dd",
-                        draw_outline=not dd_drawn,
-                        draw_arrow=mw >= 5,
-                        open_=dd_coords == c,
-                    )
-                else:
-                    mw = crightgridln - cleftgridln - 1
-                    draw_x = crightgridln - 3
-
-            elif align == "center":
-                if kwargs:
-                    mw = crightgridln - cleftgridln - self.MT.header_txt_height - 2
-                    draw_x = cleftgridln + ceil((crightgridln - cleftgridln - self.MT.header_txt_height) / 2)
-                    self.redraw_dropdown(
-                        cleftgridln,
-                        0,
-                        crightgridln,
-                        self.current_height - 1,
-                        fill=fill if kwargs["state"] != "disabled" else self.PAR.ops.header_grid_fg,
-                        outline=fill,
-                        tag="dd",
-                        draw_outline=not dd_drawn,
-                        draw_arrow=mw >= 5,
-                        open_=dd_coords == c,
-                    )
-                else:
-                    mw = crightgridln - cleftgridln - 1
+            if kwargs := self.get_cell_kwargs(datacn, key="dropdown"):
+                max_width = crightgridln - cleftgridln - txt_h - 2
+                if align.endswith("w"):
+                    draw_x = cleftgridln + 2
+                elif align.endswith("e"):
+                    draw_x = crightgridln - 5 - txt_h
+                elif align.endswith("n"):
+                    draw_x = cleftgridln + ceil((crightgridln - cleftgridln - txt_h) / 2)
+                self.redraw_dropdown(
+                    cleftgridln,
+                    0,
+                    crightgridln,
+                    self.current_height - 1,
+                    fill=fill if kwargs["state"] != "disabled" else self.ops.header_grid_fg,
+                    outline=fill,
+                    tag="dd",
+                    draw_outline=not dd_drawn,
+                    draw_arrow=max_width >= 5,
+                    open_=dd_coords == c,
+                )
+            else:
+                max_width = crightgridln - cleftgridln - 2
+                if align.endswith("w"):
+                    draw_x = cleftgridln + 2
+                elif align.endswith("e"):
+                    draw_x = crightgridln - 2
+                elif align.endswith("n"):
                     draw_x = cleftgridln + floor((crightgridln - cleftgridln) / 2)
-            if not kwargs:
-                kwargs = self.get_cell_kwargs(datacn, key="checkbox")
-                if kwargs and mw > self.MT.header_txt_height + 1:
-                    box_w = self.MT.header_txt_height + 1
-                    if align == "w":
+                if (kwargs := self.get_cell_kwargs(datacn, key="checkbox")) and max_width > txt_h + 1:
+                    box_w = txt_h + 1
+                    if align.endswith("w"):
                         draw_x += box_w + 3
-                    elif align == "center":
+                    elif align.endswith("n"):
                         draw_x += ceil(box_w / 2) + 1
-                    mw -= box_w + 3
+                    max_width -= box_w + 4
                     try:
                         draw_check = (
                             self.MT._headers[datacn]
@@ -1577,98 +1612,99 @@ class ColumnHeaders(tk.Canvas):
                     self.redraw_checkbox(
                         cleftgridln + 2,
                         2,
-                        cleftgridln + self.MT.header_txt_height + 3,
-                        self.MT.header_txt_height + 3,
-                        fill=fill if kwargs["state"] == "normal" else self.PAR.ops.header_grid_fg,
+                        cleftgridln + txt_h + 3,
+                        txt_h + 3,
+                        fill=fill if kwargs["state"] == "normal" else self.ops.header_grid_fg,
                         outline="",
                         tag="cb",
                         draw_check=draw_check,
                     )
-            lns = self.get_valid_cell_data_as_str(datacn, fix=False)
-            if not lns:
+            if (
+                max_width < self.MT.header_txt_width
+                or (align.endswith("w") and draw_x > scrollpos_right)
+                or (align.endswith("e") and cleftgridln + 5 > scrollpos_right)
+                or (align.endswith("n") and cleftgridln + 5 > scrollpos_right)
+            ):
+                continue
+            text = self.get_valid_cell_data_as_str(datacn, fix=False)
+            if not text:
                 continue
-            lns = lns.split("\n")
-            if mw > self.MT.header_txt_width and not (
-                (align == "w" and draw_x > scrollpos_right)
-                or (align == "e" and cleftgridln + 5 > scrollpos_right)
-                or (align == "center" and cleftgridln + 5 > scrollpos_right)
+            max_lines = int((self.current_height - top - 2) / txt_h)
+            for text in wrap_text(
+                text=text,
+                max_width=max_width,
+                max_lines=max_lines,
+                char_width_fn=self.wrap_get_char_w,
+                widths=self.MT.char_widths[font],
+                wrap=wrap,
             ):
-                for txt in islice(
-                    lns,
-                    self.lines_start_at if self.lines_start_at < len(lns) else len(lns) - 1,
-                    None,
-                ):
-                    if draw_y > top:
-                        if self.hidd_text:
-                            iid, showing = self.hidd_text.popitem()
-                            self.coords(iid, draw_x, draw_y)
-                            if showing:
-                                self.itemconfig(
-                                    iid,
-                                    text=txt,
-                                    fill=fill,
-                                    font=font,
-                                    anchor=align,
-                                )
-                            else:
-                                self.itemconfig(
-                                    iid,
-                                    text=txt,
-                                    fill=fill,
-                                    font=font,
-                                    anchor=align,
-                                    state="normal",
-                                )
-                            self.tag_raise(iid)
-                        else:
-                            iid = self.create_text(
-                                draw_x,
-                                draw_y,
-                                text=txt,
-                                fill=fill,
-                                font=font,
-                                anchor=align,
-                                tag="t",
-                            )
-                        self.disp_text[iid] = True
-                        wd = self.bbox(iid)
-                        wd = wd[2] - wd[0]
-                        if wd > mw:
-                            if align == "w":
-                                txt = txt[: int(len(txt) * (mw / wd))]
-                                self.itemconfig(iid, text=txt)
-                                wd = self.bbox(iid)
-                                while wd[2] - wd[0] > mw:
-                                    txt = txt[:-1]
-                                    self.itemconfig(iid, text=txt)
-                                    wd = self.bbox(iid)
-                            elif align == "e":
-                                txt = txt[len(txt) - int(len(txt) * (mw / wd)) :]
-                                self.itemconfig(iid, text=txt)
-                                wd = self.bbox(iid)
-                                while wd[2] - wd[0] > mw:
-                                    txt = txt[1:]
-                                    self.itemconfig(iid, text=txt)
-                                    wd = self.bbox(iid)
-                            elif align == "center":
-                                self.c_align_cyc = cycle(self.centre_alignment_text_mod_indexes)
-                                tmod = ceil((len(txt) - int(len(txt) * (mw / wd))) / 2)
-                                txt = txt[tmod - 1 : -tmod]
-                                self.itemconfig(iid, text=txt)
-                                wd = self.bbox(iid)
-                                while wd[2] - wd[0] > mw:
-                                    txt = txt[next(self.c_align_cyc)]
-                                    self.itemconfig(iid, text=txt)
-                                    wd = self.bbox(iid)
-                                self.coords(iid, draw_x, draw_y)
-                    draw_y += self.MT.header_xtra_lines_increment
-                    if draw_y - 1 > self.current_height:
-                        break
+                if self.hidd_text:
+                    iid, showing = self.hidd_text.popitem()
+                    self.coords(iid, draw_x, draw_y)
+                    if showing:
+                        self.itemconfig(
+                            iid,
+                            text=text,
+                            fill=fill,
+                            font=font,
+                            anchor=align,
+                        )
+                    else:
+                        self.itemconfig(
+                            iid,
+                            text=text,
+                            fill=fill,
+                            font=font,
+                            anchor=align,
+                            state="normal",
+                        )
+                    self.tag_raise(iid)
+                else:
+                    iid = self.create_text(
+                        draw_x,
+                        draw_y,
+                        text=text,
+                        fill=fill,
+                        font=font,
+                        anchor=align,
+                        tags="t",
+                    )
+                self.disp_text[iid] = True
+                draw_y += self.MT.header_txt_height
+        yend = self.current_height - 5
+        if (self.ops.show_vertical_grid or self.width_resizing_enabled) and col_pos_exists:
+            points = [
+                x_stop - 1,
+                self.current_height - 1,
+                scrollpos_left - 1,
+                self.current_height - 1,
+                scrollpos_left - 1,
+                -1,
+            ]
+            for c in range(grid_start_col, grid_end_col):
+                draw_x = self.MT.col_positions[c]
+                if c and self.width_resizing_enabled:
+                    self.visible_col_dividers[c] = (draw_x - 2, 1, draw_x + 2, yend)
+                points.extend(
+                    (
+                        draw_x,
+                        -1,
+                        draw_x,
+                        self.current_height,
+                        draw_x,
+                        -1,
+                        self.MT.col_positions[c + 1] if len(self.MT.col_positions) - 1 > c else draw_x,
+                        -1,
+                    )
+                )
+            self.redraw_gridline(points=points, fill=self.ops.header_grid_fg, width=1, tag="v")
         for dct in (self.hidd_text, self.hidd_high, self.hidd_grid, self.hidd_dropdown, self.hidd_checkbox):
             for iid, showing in dct.items():
                 if showing:
                     self.itemconfig(iid, state="hidden")
                     dct[iid] = False
+        if self.disp_resize_lines:
+            self.tag_raise("rw")
         return True
 
     def get_redraw_selections(self, startc: int, endc: int) -> dict[str, set[int]]:
@@ -1747,7 +1783,7 @@ class ColumnHeaders(tk.Canvas):
                 return False
             else:
                 text = text if isinstance(text, str) else f"{text}"
-        if self.PAR.ops.cell_auto_resize_enabled:
+        if self.ops.cell_auto_resize_enabled:
             if self.height_resizing_enabled:
                 self.set_height_of_header_to_text(text)
             self.set_col_width_run_binding(c)
@@ -1756,7 +1792,7 @@ class ColumnHeaders(tk.Canvas):
             return False
         self.hide_text_editor()
         if not self.MT.see(r=0, c=c, keep_yscroll=True, check_cell_visibility=True):
-            self.MT.refresh()
+            self.MT.main_table_redraw_grid_and_text(True, True)
         x = self.MT.col_positions[c] + 1
         y = 0
         w = self.MT.col_positions[c + 1] - x
@@ -1764,24 +1800,24 @@ class ColumnHeaders(tk.Canvas):
         kwargs = {
             "menu_kwargs": DotDict(
                 {
-                    "font": self.PAR.ops.table_font,
-                    "foreground": self.PAR.ops.popup_menu_fg,
-                    "background": self.PAR.ops.popup_menu_bg,
-                    "activebackground": self.PAR.ops.popup_menu_highlight_bg,
-                    "activeforeground": self.PAR.ops.popup_menu_highlight_fg,
+                    "font": self.ops.table_font,
+                    "foreground": self.ops.popup_menu_fg,
+                    "background": self.ops.popup_menu_bg,
+                    "activebackground": self.ops.popup_menu_highlight_bg,
+                    "activeforeground": self.ops.popup_menu_highlight_fg,
                 }
             ),
-            "sheet_ops": self.PAR.ops,
-            "border_color": self.PAR.ops.header_selected_columns_bg,
+            "sheet_ops": self.ops,
+            "border_color": self.ops.header_selected_columns_bg,
             "text": text,
             "state": state,
             "width": w,
             "height": h,
             "show_border": True,
-            "bg": self.PAR.ops.header_editor_bg,
-            "fg": self.PAR.ops.header_editor_fg,
-            "select_bg": self.PAR.ops.header_editor_select_bg,
-            "select_fg": self.PAR.ops.header_editor_select_fg,
+            "bg": self.ops.header_editor_bg,
+            "fg": self.ops.header_editor_fg,
+            "select_bg": self.ops.header_editor_select_bg,
+            "select_fg": self.ops.header_editor_select_fg,
             "align": self.get_cell_align(c),
             "c": c,
         }
@@ -1841,7 +1877,7 @@ class ColumnHeaders(tk.Canvas):
             > curr_height
         ):
             c = self.text_editor.column
-            new_height = curr_height + self.MT.header_xtra_lines_increment
+            new_height = curr_height + self.MT.header_txt_height
             space_bot = self.MT.get_space_bot(0)
             if new_height > space_bot:
                 new_height = space_bot
@@ -1864,7 +1900,7 @@ class ColumnHeaders(tk.Canvas):
                 height=self.current_height,
                 width=self.MT.col_positions[c + 1] - self.MT.col_positions[c] + 1,
             )
-            self.text_editor.tktext.config(font=self.PAR.ops.header_font)
+            self.text_editor.tktext.config(font=self.ops.header_font)
             self.coords(
                 self.text_editor.canvas_id,
                 self.MT.col_positions[c],
@@ -1972,15 +2008,12 @@ class ColumnHeaders(tk.Canvas):
         for i, v in enumerate(self.get_cell_kwargs(datacn, key="dropdown")["values"]):
             v_numlines = len(v.split("\n") if isinstance(v, str) else f"{v}".split("\n"))
             if v_numlines > 1:
-                win_h += (
-                    self.MT.header_first_ln_ins + (v_numlines * self.MT.header_xtra_lines_increment) + 5
-                )  # end of cell
+                win_h += self.MT.header_txt_height + (v_numlines * self.MT.header_txt_height) + 5  # end of cell
             else:
                 win_h += self.MT.min_header_height
             if i == 5:
                 break
-        if win_h > 500:
-            win_h = 500
+        win_h = min(win_h, 500)
         space_bot = self.MT.get_space_bot(0, text_editor_h)
         win_h2 = int(win_h)
         if win_h > space_bot:
@@ -2029,15 +2062,15 @@ class ColumnHeaders(tk.Canvas):
         reset_kwargs = {
             "r": 0,
             "c": c,
-            "bg": self.PAR.ops.header_editor_bg,
-            "fg": self.PAR.ops.header_editor_fg,
-            "select_bg": self.PAR.ops.header_editor_select_bg,
-            "select_fg": self.PAR.ops.header_editor_select_fg,
+            "bg": self.ops.header_editor_bg,
+            "fg": self.ops.header_editor_fg,
+            "select_bg": self.ops.header_editor_select_bg,
+            "select_fg": self.ops.header_editor_select_fg,
             "width": win_w,
             "height": win_h,
-            "font": self.PAR.ops.header_font,
-            "ops": self.PAR.ops,
-            "outline_color": self.PAR.ops.header_selected_columns_bg,
+            "font": self.ops.header_font,
+            "ops": self.ops,
+            "outline_color": self.ops.header_selected_columns_bg,
             "align": self.get_cell_align(c),
             "values": kwargs["values"],
             "search_function": kwargs["search_function"],
@@ -2049,7 +2082,7 @@ class ColumnHeaders(tk.Canvas):
             self.coords(self.dropdown.canvas_id, self.MT.col_positions[c], ypos)
             self.dropdown.window.tkraise()
         else:
-            self.dropdown.window = self.PAR.dropdown_class(
+            self.dropdown.window = self.PAR._dropdown_cls(
                 self.winfo_toplevel(),
                 **reset_kwargs,
                 single_index="c",
@@ -2092,13 +2125,11 @@ class ColumnHeaders(tk.Canvas):
         if c is not None and selection is not None:
             datacn = c if self.MT.all_columns_displayed else self.MT.displayed_columns[c]
             kwargs = self.get_cell_kwargs(datacn, key="dropdown")
-            pre_edit_value = self.get_cell_data(datacn)
-            edited = False
             event_data = event_dict(
                 name="end_edit_header",
                 sheet=self.PAR.name,
                 widget=self,
-                cells_header={datacn: pre_edit_value},
+                cells_header={datacn: self.get_cell_data(datacn)},
                 key="??",
                 value=selection,
                 loc=c,
@@ -2106,16 +2137,12 @@ class ColumnHeaders(tk.Canvas):
                 boxes=self.MT.get_boxes(),
                 selected=self.MT.selected,
             )
-            if kwargs["select_function"] is not None:
-                kwargs["select_function"](event_data)
-            if self.MT.edit_validation_func:
-                selection = self.MT.edit_validation_func(event_data)
-                if selection is not None:
-                    edited = self.set_cell_data_undo(c, datacn=datacn, value=selection, redraw=not redraw)
-            else:
+            try_binding(kwargs["select_function"], event_data)
+            selection = selection if not self.MT.edit_validation_func else self.MT.edit_validation_func(event_data)
+            if selection is not None:
                 edited = self.set_cell_data_undo(c, datacn=datacn, value=selection, redraw=not redraw)
-            if edited:
-                try_binding(self.extra_end_edit_cell_func, event_data)
+                if edited:
+                    try_binding(self.extra_end_edit_cell_func, event_data)
             self.MT.recreate_all_selection_boxes()
         self.focus_set()
         self.hide_text_editor_and_dropdown(redraw=redraw)
@@ -2191,7 +2218,7 @@ class ColumnHeaders(tk.Canvas):
                     self.MT.undo_stack.append(stored_event_dict(event_data))
                 self.set_cell_data(datacn=datacn, value=value)
                 edited = True
-        if edited and cell_resize and self.PAR.ops.cell_auto_resize_enabled:
+        if edited and cell_resize and self.ops.cell_auto_resize_enabled:
             if self.height_resizing_enabled:
                 self.set_height_of_header_to_text(self.get_valid_cell_data_as_str(datacn, fix=False))
             self.set_col_width_run_binding(c)
@@ -2264,11 +2291,15 @@ class ColumnHeaders(tk.Canvas):
         if fix:
             self.fix_header(datacn)
         try:
-            value = "" if self.MT._headers[datacn] is None else f"{self.MT._headers[datacn]}"
+            value = self.MT._headers[datacn]
+            if value is None:
+                value = ""
+            elif not isinstance(value, str):
+                value = f"{value}"
         except Exception:
             value = ""
-        if not value and self.PAR.ops.show_default_header_for_empty:
-            value = get_n2a(datacn, self.PAR.ops.default_header)
+        if not value and self.ops.show_default_header_for_empty:
+            value = get_n2a(datacn, self.ops.default_header)
         return value
 
     def get_value_for_empty_cell(self, datacn: int, c_ops: bool = True) -> object: