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

tksheet/__init__.py

@@ -4,7 +4,7 @@
 tksheet - A Python tkinter table widget
 """
 
-__version__ = "7.1.4"
+__version__ = "7.1.5"
 
 from .colors import (
     color_map,

tksheet/column_headers.py

@@ -272,7 +272,9 @@ class ColumnHeaders(tk.Canvas):
                     if self.MT.selected and self.MT.selected.type_ == "columns":
                         r_to_sel, c_to_sel = self.MT.selected.row, self.MT.selected.column
                         self.MT.deselect("all", redraw=False)
-                        self.being_drawn_item = self.MT.create_selection_box(*self.get_shift_select_box(c, c_to_sel), "columns")
+                        self.being_drawn_item = self.MT.create_selection_box(
+                            *self.get_shift_select_box(c, c_to_sel), "columns"
+                        )
                         self.MT.set_currently_selected(r_to_sel, c_to_sel, self.being_drawn_item)
                     else:
                         self.being_drawn_item = self.select_col(c, run_binding_func=False)
@@ -854,8 +856,16 @@ class ColumnHeaders(tk.Canvas):
             ):
                 datacn = c if self.MT.all_columns_displayed else self.MT.displayed_columns[c]
                 canvasx = self.canvasx(event.x)
-                if self.event_over_dropdown(c, datacn, event, canvasx) or self.event_over_checkbox(
-                    c, datacn, event, canvasx
+                if self.event_over_dropdown(
+                    c,
+                    datacn,
+                    event,
+                    canvasx,
+                ) or self.event_over_checkbox(
+                    c,
+                    datacn,
+                    event,
+                    canvasx,
                 ):
                     self.open_cell(event)
             else:
@@ -970,15 +980,15 @@ 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
         new_height = self.MT.min_header_height
         default_header_height = self.MT.get_default_header_height()
         self.fix_header()
         if text is not None:
             if text:
-                qconf(qtxtm, text=text)
+                qconf(qtxtm, text=text, font=qfont)
                 b = qbbox(qtxtm)
-                h = b[3] - b[1] + 5
-                if h > new_height:
+                if (h := b[3] - b[1] + 5) > new_height:
                     new_height = h
         else:
             if self.MT.all_columns_displayed:
@@ -1002,7 +1012,7 @@ class ColumnHeaders(tk.Canvas):
                 for datacn in iterable:
                     txt = self.MT.get_valid_cell_data_as_str(datarn, datacn, get_displayed=True)
                     if txt:
-                        qconf(qtxtm, text=txt)
+                        qconf(qtxtm, text=txt, font=qfont)
                         b = qbbox(qtxtm)
                         h = b[3] - b[1] + 5
                     else:
@@ -1014,7 +1024,7 @@ class ColumnHeaders(tk.Canvas):
                     if h > new_height:
                         new_height = h
         space_bot = self.MT.get_space_bot(0)
-        if new_height > space_bot:
+        if new_height > space_bot and space_bot > self.MT.min_header_height:
             new_height = space_bot
         if not only_increase or (only_increase and new_height > self.current_height):
             self.set_height(new_height, set_TL=True)
@@ -1684,12 +1694,12 @@ class ColumnHeaders(tk.Canvas):
                 }
             ),
             "sheet_ops": self.PAR.ops,
-            "border_color": self.PAR.ops.table_selected_cells_border_fg,
+            "border_color": self.PAR.ops.header_selected_columns_bg,
             "text": text,
             "state": state,
             "width": w,
             "height": h,
-            "show_border": self.PAR.ops.show_selected_cells_border,
+            "show_border": True,
             "bg": bg,
             "fg": fg,
             "align": self.get_cell_align(c),
@@ -1735,31 +1745,34 @@ class ColumnHeaders(tk.Canvas):
 
     # displayed indexes
     def text_editor_newline_binding(self, r=0, c=0, event: object = None, check_lines=True):
-        if self.height_resizing_enabled:
-            curr_height = self.text_editor.window.winfo_height()
-            if (
-                not check_lines
-                or self.MT.get_lines_cell_height(
-                    self.text_editor.window.get_num_lines() + 1,
-                    font=self.PAR.ops.header_font,
-                )
-                > curr_height
-            ):
-                new_height = curr_height + self.MT.header_xtra_lines_increment
-                space_bot = self.MT.get_space_bot(0)
-                if new_height > space_bot:
-                    new_height = space_bot
-                if new_height != curr_height:
-                    self.text_editor.window.config(height=new_height)
-                    self.set_height(new_height, set_TL=True)
-                    if self.dropdown.open and self.dropdown.get_coords() == c:
-                        win_h, anchor = self.get_dropdown_height_anchor(c, new_height)
-                        self.coords(
-                            self.dropdown.canvas_id,
-                            self.MT.col_positions[c],
-                            new_height - 1,
-                        )
-                        self.itemconfig(self.dropdown.canvas_id, anchor=anchor, height=win_h)
+        if not self.height_resizing_enabled:
+            return
+        curr_height = self.text_editor.window.winfo_height()
+        if curr_height < self.MT.min_header_height:
+            return
+        if (
+            not check_lines
+            or self.MT.get_lines_cell_height(
+                self.text_editor.window.get_num_lines() + 1,
+                font=self.PAR.ops.header_font,
+            )
+            > curr_height
+        ):
+            new_height = curr_height + self.MT.header_xtra_lines_increment
+            space_bot = self.MT.get_space_bot(0)
+            if new_height > space_bot:
+                new_height = space_bot
+            if new_height != curr_height:
+                self.text_editor.window.config(height=new_height)
+                self.set_height(new_height, set_TL=True)
+                if self.dropdown.open and self.dropdown.get_coords() == c:
+                    win_h, anchor = self.get_dropdown_height_anchor(c, new_height)
+                    self.coords(
+                        self.dropdown.canvas_id,
+                        self.MT.col_positions[c],
+                        new_height - 1,
+                    )
+                    self.itemconfig(self.dropdown.canvas_id, anchor=anchor, height=win_h)
 
     def refresh_open_window_positions(self):
         if self.text_editor.open:
@@ -1897,33 +1910,32 @@ class ColumnHeaders(tk.Canvas):
             if not self.open_text_editor(event=event, c=c, dropdown=True):
                 return
         win_h, anchor = self.get_dropdown_height_anchor(c)
+        win_w = self.MT.col_positions[c + 1] - self.MT.col_positions[c] + 1
         ypos = self.current_height - 1
-        if self.dropdown.window is not None:
-            self.dropdown.window.search_function = kwargs["search_function"]
-            self.dropdown.window.c = c
-            self.dropdown.window.row = -1
-            self.dropdown.window.set_options()
-            self.dropdown.window.values(kwargs["values"])
-            if not self.dropdown.open:
-                self.itemconfig(self.dropdown.canvas_id, state="normal")
+        reset_kwargs = {
+            "r": 0,
+            "c": c,
+            "width": win_w,
+            "height": win_h,
+            "font": self.PAR.ops.header_font,
+            "ops": self.PAR.ops,
+            "outline_color": self.PAR.ops.popup_menu_fg,
+            "align": self.get_cell_align(c),
+            "values": kwargs["values"],
+        }
+        if self.dropdown.window:
+            self.dropdown.window.reset(**reset_kwargs)
+            self.itemconfig(self.dropdown.canvas_id, state="normal")
             self.coords(self.dropdown.canvas_id, self.MT.col_positions[c], ypos)
         else:
             self.dropdown.window = self.PAR.dropdown_class(
-                self.MT.winfo_toplevel(),
-                0,
-                c,
-                width=self.MT.col_positions[c + 1] - self.MT.col_positions[c] + 1,
-                height=win_h,
-                font=self.PAR.ops.header_font,
-                ops=self.PAR.ops,
-                outline_color=self.PAR.ops.popup_menu_fg,
-                values=kwargs["values"],
+                self.winfo_toplevel(),
+                **reset_kwargs,
+                single_index="c",
                 close_dropdown_window=self.close_dropdown_window,
                 search_function=kwargs["search_function"],
                 arrowkey_RIGHT=self.MT.arrowkey_RIGHT,
                 arrowkey_LEFT=self.MT.arrowkey_LEFT,
-                align="w",
-                single_index="c",
             )
             self.dropdown.canvas_id = self.create_window(
                 (self.MT.col_positions[c], ypos),

tksheet/functions.py

@@ -1146,6 +1146,22 @@ def set_readonly(
     return options
 
 
+def convert_align(align: str | None) -> str | None:
+    if isinstance(align, str):
+        a = align.lower()
+        if a == "global":
+            return None
+        elif a in ("c", "center", "centre"):
+            return "center"
+        elif a in ("w", "west", "left"):
+            return "w"
+        elif a in ("e", "east", "right"):
+            return "e"
+    elif align is None:
+        return None
+    raise ValueError("Align must be one of the following values: c, center, w, west, left, e, east, right")
+
+
 def set_align(
     options: dict,
     key: int | tuple[int, int],

tksheet/main_table.py

@@ -1803,7 +1803,7 @@ class MainTable(tk.Canvas):
                 cells=False,
             ):
                 self.hide_selection_box(item)
-        elif r is not None and c is None and cell is None:
+        elif isinstance(r, int) and c is None and cell is None:
             for item, box in self.get_selection_items(columns=False, cells=False):
                 r1, c1, r2, c2 = box.coords
                 if r >= r1 and r < r2:
@@ -1847,7 +1847,7 @@ class MainTable(tk.Canvas):
                                 set_current=resel and to_sel >= r + 1 and to_sel < r2,
                             )
                     break
-        elif c is not None and r is None and cell is None:
+        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
                 if c >= c1 and c < c2:
@@ -1891,7 +1891,7 @@ class MainTable(tk.Canvas):
                                 set_current=resel and to_sel >= c + 1 and to_sel < c2,
                             )
                     break
-        elif (r is not None and c is not None and cell is None) or cell is not None:
+        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]
             for item, box in self.get_selection_items(reverse=True):
@@ -1970,7 +1970,7 @@ class MainTable(tk.Canvas):
             return
         if self.selected.type_ == "rows":
             r = self.selected.row
-            if r != 0 and self.RI.row_selection_enabled:
+            if r and self.RI.row_selection_enabled:
                 if self.cell_completely_visible(r=r - 1, c=0):
                     self.RI.select_row(r - 1, redraw=True)
                 else:
@@ -1979,63 +1979,16 @@ class MainTable(tk.Canvas):
         elif self.selected.type_ in ("cells", "columns"):
             r = self.selected.row
             c = self.selected.column
-            if r == 0 and self.CH.col_selection_enabled:
+            if not r and self.CH.col_selection_enabled:
                 if not self.cell_completely_visible(r=r, c=0):
-                    self.see(r, c, keep_xscroll=True, check_cell_visibility=False)
-            elif r != 0 and (self.single_selection_enabled or self.toggle_selection_enabled):
+                    self.see(r, c, check_cell_visibility=False)
+            elif r and (self.single_selection_enabled or self.toggle_selection_enabled):
                 if self.cell_completely_visible(r=r - 1, c=c):
                     self.select_cell(r - 1, c, redraw=True)
                 else:
                     self.select_cell(r - 1, c)
                     self.see(r - 1, c, keep_xscroll=True, check_cell_visibility=False)
 
-    def arrowkey_RIGHT(self, event=None):
-        if not self.selected:
-            return
-        if self.selected.type_ == "rows":
-            r = self.selected.row
-            if self.single_selection_enabled or self.toggle_selection_enabled:
-                if self.cell_completely_visible(r=r, c=0):
-                    self.select_cell(r, 0, redraw=True)
-                else:
-                    self.select_cell(r, 0)
-                    self.see(
-                        r,
-                        0,
-                        keep_yscroll=True,
-                        bottom_right_corner=True,
-                        check_cell_visibility=False,
-                    )
-        elif self.selected.type_ == "columns":
-            c = self.selected.column
-            if c < len(self.col_positions) - 2 and self.CH.col_selection_enabled:
-                if self.cell_completely_visible(r=0, c=c + 1):
-                    self.CH.select_col(c + 1, redraw=True)
-                else:
-                    self.CH.select_col(c + 1)
-                    self.see(
-                        0,
-                        c + 1,
-                        keep_yscroll=True,
-                        bottom_right_corner=False if self.PAR.ops.arrow_key_down_right_scroll_page else True,
-                        check_cell_visibility=False,
-                    )
-        else:
-            r = self.selected.row
-            c = self.selected.column
-            if c < len(self.col_positions) - 2 and (self.single_selection_enabled or self.toggle_selection_enabled):
-                if self.cell_completely_visible(r=r, c=c + 1):
-                    self.select_cell(r, c + 1, redraw=True)
-                else:
-                    self.select_cell(r, c + 1)
-                    self.see(
-                        r,
-                        c + 1,
-                        keep_yscroll=True,
-                        bottom_right_corner=False if self.PAR.ops.arrow_key_down_right_scroll_page else True,
-                        check_cell_visibility=False,
-                    )
-
     def arrowkey_DOWN(self, event=None):
         if not self.selected:
             return
@@ -2071,15 +2024,17 @@ class MainTable(tk.Canvas):
         elif self.selected.type_ == "columns":
             c = self.selected.column
             if self.single_selection_enabled or self.toggle_selection_enabled:
-                if self.cell_completely_visible(r=0, c=c):
-                    self.select_cell(0, c, redraw=True)
+                if self.selected.row == len(self.row_positions) - 2:
+                    r = self.selected.row
                 else:
-                    self.select_cell(0, c)
+                    r = self.selected.row + 1
+                if self.cell_completely_visible(r=r, c=c):
+                    self.select_cell(r, c, redraw=True)
+                else:
+                    self.select_cell(r, c)
                     self.see(
-                        0,
+                        r,
                         c,
-                        keep_xscroll=True,
-                        bottom_right_corner=True,
                         check_cell_visibility=False,
                     )
         else:
@@ -2118,7 +2073,7 @@ class MainTable(tk.Canvas):
             return
         if self.selected.type_ == "columns":
             c = self.selected.column
-            if c != 0 and self.CH.col_selection_enabled:
+            if c and self.CH.col_selection_enabled:
                 if self.cell_completely_visible(r=0, c=c - 1):
                     self.CH.select_col(c - 1, redraw=True)
                 else:
@@ -2130,19 +2085,70 @@ class MainTable(tk.Canvas):
                         bottom_right_corner=True,
                         check_cell_visibility=False,
                     )
+        elif self.selected.type_ == "rows" and self.selected.column:
+            self.select_cell(self.selected.row, self.selected.column - 1)
+            self.see(self.selected.row, self.selected.column, check_cell_visibility=True)
         elif self.selected.type_ == "cells":
             r = self.selected.row
             c = self.selected.column
-            if c == 0 and self.RI.row_selection_enabled:
-                if not self.cell_completely_visible(r=r, c=0):
-                    self.see(r, c, keep_yscroll=True, check_cell_visibility=False)
-            elif c != 0 and (self.single_selection_enabled or self.toggle_selection_enabled):
+            if not c and not self.cell_completely_visible(r=r, c=0):
+                self.see(r, c, keep_yscroll=True, check_cell_visibility=False)
+            elif c and (self.single_selection_enabled or self.toggle_selection_enabled):
                 if self.cell_completely_visible(r=r, c=c - 1):
                     self.select_cell(r, c - 1, redraw=True)
                 else:
                     self.select_cell(r, c - 1)
                     self.see(r, c - 1, keep_yscroll=True, check_cell_visibility=False)
 
+    def arrowkey_RIGHT(self, event=None):
+        if not self.selected:
+            return
+        if self.selected.type_ == "rows":
+            r = self.selected.row
+            if self.single_selection_enabled or self.toggle_selection_enabled:
+                if self.selected.column == len(self.col_positions) - 2:
+                    c = self.selected.column
+                else:
+                    c = self.selected.column + 1
+                if self.cell_completely_visible(r=r, c=c):
+                    self.select_cell(r, c, redraw=True)
+                else:
+                    self.select_cell(r, c)
+                    self.see(
+                        r,
+                        c,
+                        check_cell_visibility=False,
+                    )
+        elif self.selected.type_ == "columns":
+            c = self.selected.column
+            if c < len(self.col_positions) - 2 and self.CH.col_selection_enabled:
+                if self.cell_completely_visible(r=0, c=c + 1):
+                    self.CH.select_col(c + 1, redraw=True)
+                else:
+                    self.CH.select_col(c + 1)
+                    self.see(
+                        0,
+                        c + 1,
+                        keep_yscroll=True,
+                        bottom_right_corner=False if self.PAR.ops.arrow_key_down_right_scroll_page else True,
+                        check_cell_visibility=False,
+                    )
+        else:
+            r = self.selected.row
+            c = self.selected.column
+            if c < len(self.col_positions) - 2 and (self.single_selection_enabled or self.toggle_selection_enabled):
+                if self.cell_completely_visible(r=r, c=c + 1):
+                    self.select_cell(r, c + 1, redraw=True)
+                else:
+                    self.select_cell(r, c + 1)
+                    self.see(
+                        r,
+                        c + 1,
+                        keep_yscroll=True,
+                        bottom_right_corner=False if self.PAR.ops.arrow_key_down_right_scroll_page else True,
+                        check_cell_visibility=False,
+                    )
+
     def key_bindings(self) -> None:
         for widget in (self, self.RI, self.CH, self.TL):
             for binding in self.PAR.ops.copy_bindings:
@@ -3376,7 +3382,7 @@ class MainTable(tk.Canvas):
     def set_table_font_help(self):
         self.table_txt_width, self.table_txt_height = self.get_txt_dimensions("|", self.PAR.ops.table_font)
         self.table_half_txt_height = ceil(self.table_txt_height / 2)
-        if self.table_half_txt_height % 2 == 0:
+        if not self.table_half_txt_height % 2:
             self.table_first_ln_ins = self.table_half_txt_height + 2
         else:
             self.table_first_ln_ins = self.table_half_txt_height + 3
@@ -3404,7 +3410,7 @@ class MainTable(tk.Canvas):
     def set_header_font_help(self):
         self.header_txt_width, self.header_txt_height = self.get_txt_dimensions("|", self.PAR.ops.header_font)
         self.header_half_txt_height = ceil(self.header_txt_height / 2)
-        if self.header_half_txt_height % 2 == 0:
+        if not self.header_half_txt_height % 2:
             self.header_first_ln_ins = self.header_half_txt_height + 2
         else:
             self.header_first_ln_ins = self.header_half_txt_height + 3
@@ -3435,7 +3441,7 @@ class MainTable(tk.Canvas):
     def set_index_font_help(self):
         self.index_txt_width, self.index_txt_height = self.get_txt_dimensions("|", self.PAR.ops.index_font)
         self.index_half_txt_height = ceil(self.index_txt_height / 2)
-        if self.index_half_txt_height % 2 == 0:
+        if not self.index_half_txt_height % 2:
             self.index_first_ln_ins = self.index_half_txt_height + 2
         else:
             self.index_first_ln_ins = self.index_half_txt_height + 3
@@ -3562,19 +3568,22 @@ class MainTable(tk.Canvas):
             else:
                 return False
 
-    def set_all_cell_sizes_to_text(self, include_index: bool = False) -> tuple[list[float], list[float]]:
+    def set_all_cell_sizes_to_text(self, w: int | None = None) -> tuple[list[float], list[float]]:
         min_column_width = int(self.min_column_width)
         min_rh = int(self.min_row_height)
-        w = min_column_width
+        w = min_column_width if w is None else w
         h = min_rh
         rhs = defaultdict(lambda: int(min_rh))
         cws = []
-        itmcon = self.txt_measure_canvas.itemconfig
-        itmbbx = self.txt_measure_canvas.bbox
-        self.txt_measure_canvas.itemconfig(self.txt_measure_canvas_text, font=self.PAR.ops.table_font)
+        qconf = self.txt_measure_canvas.itemconfig
+        qbbox = self.txt_measure_canvas.bbox
+        qtxtm = self.txt_measure_canvas_text
+        qtxth = self.table_txt_height
+        qfont = self.PAR.ops.table_font
         numrows = self.total_data_rows()
+        numcols = self.total_data_cols()
         if self.all_columns_displayed:
-            itercols = range(self.total_data_cols())
+            itercols = range(numcols)
         else:
             itercols = self.displayed_columns
         if self.all_rows_displayed:
@@ -3591,23 +3600,28 @@ class MainTable(tk.Canvas):
                 if h > rhs[datarn]:
                     rhs[datarn] = h
         for datacn in itercols:
-            w, h_ = self.CH.get_cell_dimensions(datacn)
-            if self.all_rows_displayed:
-                iterrows = range(numrows)
+            if (hw := self.CH.get_cell_dimensions(datacn)[0]) > w:
+                w = hw
             for datarn in iterrows:
                 txt = self.get_valid_cell_data_as_str(datarn, datacn, get_displayed=True)
                 if txt:
-                    itmcon(self.txt_measure_canvas_text, text=txt)
-                    b = itmbbx(self.txt_measure_canvas_text)
+                    qconf(qtxtm, text=txt, font=qfont)
+                    b = qbbox(qtxtm)
                     tw = b[2] - b[0] + 7
                     h = b[3] - b[1] + 5
                 else:
                     tw = min_column_width
                     h = min_rh
-                if self.get_cell_kwargs(datarn, datacn, key="dropdown") or self.get_cell_kwargs(
-                    datarn, datacn, key="checkbox"
+                if self.get_cell_kwargs(
+                    datarn,
+                    datacn,
+                    key="dropdown",
+                ) or self.get_cell_kwargs(
+                    datarn,
+                    datacn,
+                    key="checkbox",
                 ):
-                    tw += self.table_txt_height
+                    tw += qtxth
                 if tw > w:
                     w = tw
                 if h < min_rh:
@@ -3621,8 +3635,8 @@ class MainTable(tk.Canvas):
             elif w > self.max_column_width:
                 w = int(self.max_column_width)
             cws.append(w)
-        self.set_row_positions(itr=(height for height in rhs.values()))
-        self.set_col_positions(itr=(width for width in cws))
+        self.set_row_positions(itr=rhs.values())
+        self.set_col_positions(itr=cws)
         self.recreate_all_selection_boxes()
         return self.row_positions, self.col_positions
 
@@ -5689,6 +5703,7 @@ class MainTable(tk.Canvas):
         c: int,
         type_: Literal["cells", "rows", "columns"],
         fill_iid: int,
+        lower_selection_boxes: bool = True,
     ) -> int:
         fill, outline = self.get_selected_box_bg_fg(type_=type_)
         x1 = self.col_positions[c] + 1
@@ -5699,6 +5714,7 @@ class MainTable(tk.Canvas):
         if self.PAR.ops.show_selected_cells_border:
             fill = ""
         else:
+            fill = outline
             outline = ""
         iid = self.display_box(
             x1,
@@ -5719,10 +5735,7 @@ class MainTable(tk.Canvas):
             iid=iid,
             fill_iid=fill_iid,
         )
-        if self.PAR.ops.show_selected_cells_border:
-            self.tag_raise(iid)
-        else:
-            self.tag_lower(iid)
+        if lower_selection_boxes:
             self.lower_selection_boxes()
         return iid
 
@@ -5871,19 +5884,25 @@ class MainTable(tk.Canvas):
             elif isinstance(set_current, tuple):
                 curr_r = set_current[0]
                 curr_c = set_current[1]
-            self.create_currently_selected_box(curr_r, curr_c, type_, fill_iid)
+            self.create_currently_selected_box(curr_r, curr_c, type_, fill_iid, lower_selection_boxes=False)
         self.lower_selection_boxes()
         if run_binding:
             self.run_selection_binding(type_)
         return fill_iid
 
     def lower_selection_boxes(self) -> None:
-        for iid, box in reversed(self.selection_boxes.items()):
-            self.tag_lower(iid)
-            self.RI.tag_lower(box.index)
-            self.CH.tag_lower(box.header)
-        if self.PAR.ops.show_selected_cells_border and self.selected:
-            self.tag_raise(self.selected.iid)
+        if self.selected:
+            if not self.PAR.ops.show_selected_cells_border:
+                self.tag_lower(self.selected.iid)
+            self.tag_lower("rows")
+            self.tag_lower("columns")
+            self.tag_lower("cells")
+            self.RI.tag_lower("rows")
+            self.RI.tag_lower("cells")
+            self.CH.tag_lower("columns")
+            self.CH.tag_lower("cells")
+            if self.PAR.ops.show_selected_cells_border:
+                self.tag_raise(self.selected.iid)
 
     def recreate_selection_box(
         self,
@@ -6418,12 +6437,12 @@ class MainTable(tk.Canvas):
                 }
             ),
             "sheet_ops": self.PAR.ops,
-            "border_color": self.PAR.ops.table_selected_cells_border_fg,
+            "border_color": self.PAR.ops.table_selected_box_cells_fg,
             "text": text,
             "state": state,
             "width": w,
             "height": h,
-            "show_border": self.PAR.ops.show_selected_cells_border,
+            "show_border": True,
             "bg": bg,
             "fg": fg,
             "align": self.get_cell_align(r, c),
@@ -6462,6 +6481,8 @@ class MainTable(tk.Canvas):
         check_lines: bool = True,
     ) -> None:
         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:
             new_height = curr_height + self.table_xtra_lines_increment
             space_bot = self.get_space_bot(r)
@@ -6761,6 +6782,7 @@ class MainTable(tk.Canvas):
             if not self.open_text_editor(event=event, r=r, c=c, dropdown=True):
                 return
         win_h, anchor = self.get_dropdown_height_anchor(r, c)
+        win_w = self.col_positions[c + 1] - self.col_positions[c] + 1
         if anchor == "nw":
             if kwargs["state"] == "normal":
                 ypos = self.row_positions[r] + self.text_editor.window.winfo_height() - 1
@@ -6768,33 +6790,29 @@ class MainTable(tk.Canvas):
                 ypos = self.row_positions[r + 1]
         else:
             ypos = self.row_positions[r]
-        if self.dropdown.window is not None:
-            self.dropdown.window.search_function = kwargs["search_function"]
-            self.dropdown.window.r = r
-            self.dropdown.window.c = c
-            self.dropdown.window.row = -1
-            self.dropdown.window.set_options()
-            self.dropdown.window.values(kwargs["values"])
-            if not self.dropdown.open:
-                self.itemconfig(self.dropdown.canvas_id, state="normal")
+        reset_kwargs = {
+            "r": r,
+            "c": c,
+            "width": win_w,
+            "height": win_h,
+            "font": self.PAR.ops.table_font,
+            "ops": self.PAR.ops,
+            "outline_color": self.get_selected_box_bg_fg(type_="cells")[1],
+            "align": self.get_cell_align(r, c),
+            "values": kwargs["values"],
+        }
+        if self.dropdown.window:
+            self.dropdown.window.reset(**reset_kwargs)
+            self.itemconfig(self.dropdown.canvas_id, state="normal")
             self.coords(self.dropdown.canvas_id, self.col_positions[c], ypos)
         else:
             self.dropdown.window = self.PAR.dropdown_class(
                 self.winfo_toplevel(),
-                r,
-                c,
-                width=self.col_positions[c + 1] - self.col_positions[c] + 1,
-                height=win_h,
-                font=self.PAR.ops.table_font,
-                ops=self.PAR.ops,
-                outline_color=self.get_selected_box_bg_fg(type_="cells")[1],
-                outline_thickness=2,
-                values=kwargs["values"],
+                **reset_kwargs,
                 close_dropdown_window=self.close_dropdown_window,
                 search_function=kwargs["search_function"],
                 arrowkey_RIGHT=self.arrowkey_RIGHT,
                 arrowkey_LEFT=self.arrowkey_LEFT,
-                align="w",  # self.get_cell_align(r, c)
             )
             self.dropdown.canvas_id = self.create_window(
                 (self.col_positions[c], ypos),

tksheet/row_index.py

@@ -266,7 +266,9 @@ class RowIndex(tk.Canvas):
                     if self.MT.selected and self.MT.selected.type_ == "rows":
                         r_to_sel, c_to_sel = self.MT.selected.row, self.MT.selected.column
                         self.MT.deselect("all", redraw=False)
-                        self.being_drawn_item = self.MT.create_selection_box(*self.get_shift_select_box(r, r_to_sel), "rows")
+                        self.being_drawn_item = self.MT.create_selection_box(
+                            *self.get_shift_select_box(r, r_to_sel), "rows"
+                        )
                         self.MT.set_currently_selected(r_to_sel, c_to_sel, self.being_drawn_item)
                     else:
                         self.being_drawn_item = self.select_row(r, run_binding_func=False)
@@ -1756,9 +1758,9 @@ class RowIndex(tk.Canvas):
         if not self.MT.see(r=r, c=0, keep_yscroll=True, check_cell_visibility=True):
             self.MT.refresh()
         x = 0
-        y = self.MT.row_positions[r] + 1
+        y = self.MT.row_positions[r]
         w = self.current_width + 1
-        h = self.MT.row_positions[r + 1] - y
+        h = self.MT.row_positions[r + 1] - y + 1
         datarn = r if self.MT.all_rows_displayed else self.MT.displayed_rows[r]
         if text is None:
             text = self.get_cell_data(datarn, none_to_empty_str=True, redirect_int=True)
@@ -1774,12 +1776,12 @@ class RowIndex(tk.Canvas):
                 }
             ),
             "sheet_ops": self.PAR.ops,
-            "border_color": self.PAR.ops.table_selected_cells_border_fg,
+            "border_color": self.PAR.ops.index_selected_rows_bg,
             "text": text,
             "state": state,
             "width": w,
             "height": h,
-            "show_border": self.PAR.ops.show_selected_cells_border,
+            "show_border": True,
             "bg": bg,
             "fg": fg,
             "align": self.get_cell_align(r),
@@ -1809,42 +1811,45 @@ class RowIndex(tk.Canvas):
         return True
 
     def text_editor_newline_binding(self, r=0, c=0, event: object = None, check_lines=True):
-        if self.height_resizing_enabled:
-            curr_height = self.text_editor.window.winfo_height()
-            if (
-                not check_lines
-                or self.MT.get_lines_cell_height(
-                    self.text_editor.window.get_num_lines() + 1,
-                    font=self.PAR.ops.index_font,
-                )
-                > curr_height
-            ):
-                new_height = curr_height + self.MT.index_xtra_lines_increment
-                space_bot = self.MT.get_space_bot(r)
-                if new_height > space_bot:
-                    new_height = space_bot
-                if new_height != curr_height:
-                    self.set_row_height(r, new_height)
-                    self.MT.refresh()
-                    self.text_editor.window.config(height=new_height)
-                    self.coords(self.text_editor.canvas_id, 0, self.MT.row_positions[r] + 1)
-                    if self.dropdown.open and self.dropdown.get_coords() == r:
-                        text_editor_h = self.text_editor.window.winfo_height()
-                        win_h, anchor = self.get_dropdown_height_anchor(r, text_editor_h)
-                        if anchor == "nw":
-                            self.coords(
-                                self.dropdown.canvas_id,
-                                self.MT.col_positions[c],
-                                self.MT.row_positions[r] + text_editor_h - 1,
-                            )
-                            self.itemconfig(self.dropdown.canvas_id, anchor=anchor, height=win_h)
-                        elif anchor == "sw":
-                            self.coords(
-                                self.dropdown.canvas_id,
-                                self.MT.col_positions[c],
-                                self.MT.row_positions[r],
-                            )
-                            self.itemconfig(self.dropdown.canvas_id, anchor=anchor, height=win_h)
+        if not self.height_resizing_enabled:
+            return
+        curr_height = self.text_editor.window.winfo_height()
+        if curr_height < self.MT.min_row_height:
+            return
+        if (
+            not check_lines
+            or self.MT.get_lines_cell_height(
+                self.text_editor.window.get_num_lines() + 1,
+                font=self.PAR.ops.index_font,
+            )
+            > curr_height
+        ):
+            new_height = curr_height + self.MT.index_xtra_lines_increment
+            space_bot = self.MT.get_space_bot(r)
+            if new_height > space_bot:
+                new_height = space_bot
+            if new_height != curr_height:
+                self.set_row_height(r, new_height)
+                self.MT.refresh()
+                self.text_editor.window.config(height=new_height)
+                self.coords(self.text_editor.canvas_id, 0, self.MT.row_positions[r] + 1)
+                if self.dropdown.open and self.dropdown.get_coords() == r:
+                    text_editor_h = self.text_editor.window.winfo_height()
+                    win_h, anchor = self.get_dropdown_height_anchor(r, text_editor_h)
+                    if anchor == "nw":
+                        self.coords(
+                            self.dropdown.canvas_id,
+                            self.MT.col_positions[c],
+                            self.MT.row_positions[r] + text_editor_h - 1,
+                        )
+                        self.itemconfig(self.dropdown.canvas_id, anchor=anchor, height=win_h)
+                    elif anchor == "sw":
+                        self.coords(
+                            self.dropdown.canvas_id,
+                            self.MT.col_positions[c],
+                            self.MT.row_positions[r],
+                        )
+                        self.itemconfig(self.dropdown.canvas_id, anchor=anchor, height=win_h)
 
     def refresh_open_window_positions(self):
         if self.text_editor.open:
@@ -1981,33 +1986,32 @@ class RowIndex(tk.Canvas):
             if not self.open_text_editor(event=event, r=r, dropdown=True):
                 return
         win_h, anchor = self.get_dropdown_height_anchor(r)
+        win_w = self.current_width
         ypos = self.MT.row_positions[r + 1]
-        if self.dropdown.window is not None:
-            self.dropdown.window.search_function = kwargs["search_function"]
-            self.dropdown.window.r = r
-            self.dropdown.window.row = -1
-            self.dropdown.window.set_options()
-            self.dropdown.window.values(kwargs["values"])
-            if not self.dropdown.open:
-                self.itemconfig(self.dropdown.canvas_id, state="normal")
+        reset_kwargs = {
+            "r": r,
+            "c": 0,
+            "width": win_w,
+            "height": win_h,
+            "font": self.PAR.ops.index_font,
+            "ops": self.PAR.ops,
+            "outline_color": self.PAR.ops.popup_menu_fg,
+            "align": self.get_cell_align(r),
+            "values": kwargs["values"],
+        }
+        if self.dropdown.window:
+            self.dropdown.window.reset(**reset_kwargs)
+            self.itemconfig(self.dropdown.canvas_id, state="normal")
             self.coords(self.dropdown.canvas_id, 0, ypos)
         else:
             self.dropdown.window = self.PAR.dropdown_class(
-                self.MT.winfo_toplevel(),
-                r,
-                0,
-                width=self.current_width,
-                height=win_h,
-                font=self.PAR.ops.index_font,
-                ops=self.PAR.ops,
-                outline_color=self.PAR.ops.popup_menu_fg,
-                values=kwargs["values"],
+                self.winfo_toplevel(),
+                **reset_kwargs,
+                single_index="r",
                 close_dropdown_window=self.close_dropdown_window,
                 search_function=kwargs["search_function"],
                 arrowkey_RIGHT=self.MT.arrowkey_RIGHT,
                 arrowkey_LEFT=self.MT.arrowkey_LEFT,
-                align="w",
-                single_index="r",
             )
             self.dropdown.canvas_id = self.create_window(
                 (0, ypos),

tksheet/sheet.py

@@ -14,6 +14,7 @@ from .column_headers import ColumnHeaders
 from .functions import (
     add_highlight,
     add_to_options,
+    convert_align,
     data_to_displayed_idxs,
     del_from_options,
     del_named_span_options,
@@ -314,14 +315,14 @@ class Sheet(tk.Frame):
         self.RI = RowIndex(
             parent=self,
             row_index_align=(
-                self.convert_align(row_index_align) if row_index_align is not None else self.convert_align(index_align)
+                convert_align(row_index_align) if row_index_align is not None else convert_align(index_align)
             ),
             default_row_index=default_row_index,
         )
         self.CH = ColumnHeaders(
             parent=self,
             default_header=default_header,
-            header_align=self.convert_align(header_align),
+            header_align=convert_align(header_align),
         )
         self.MT = MainTable(
             parent=self,
@@ -341,7 +342,7 @@ class Sheet(tk.Frame):
             row_index=row_index,
             index=index,
             zoom=zoom,
-            align=self.convert_align(align),
+            align=convert_align(align),
             displayed_columns=displayed_columns,
             all_columns_displayed=all_columns_displayed,
             displayed_rows=displayed_rows,
@@ -2796,21 +2797,6 @@ class Sheet(tk.Frame):
     def header_font(self, newfont: tuple[str, int, str] | None = None) -> tuple[str, int, str]:
         return self.MT.set_header_font(newfont)
 
-    def convert_align(self, align: str | None) -> str | None:
-        if isinstance(align, str):
-            a = align.lower()
-            if a == "global":
-                return None
-            elif a in ("c", "center", "centre"):
-                return "center"
-            elif a in ("w", "west", "left"):
-                return "w"
-            elif a in ("e", "east", "right"):
-                return "e"
-        elif align is None:
-            return None
-        raise ValueError("Align must be one of the following values: c, center, w, west, left, e, east, right")
-
     def table_align(
         self,
         align: str = None,
@@ -2818,8 +2804,8 @@ class Sheet(tk.Frame):
     ) -> str | Sheet:
         if align is None:
             return self.MT.align
-        elif self.convert_align(align):
-            self.MT.align = self.convert_align(align)
+        elif convert_align(align):
+            self.MT.align = convert_align(align)
         else:
             raise ValueError("Align must be one of the following values: c, center, w, west, e, east")
         self.set_refresh_timer(redraw)
@@ -2832,8 +2818,8 @@ class Sheet(tk.Frame):
     ) -> str | Sheet:
         if align is None:
             return self.CH.align
-        elif self.convert_align(align):
-            self.CH.align = self.convert_align(align)
+        elif convert_align(align):
+            self.CH.align = convert_align(align)
         else:
             raise ValueError("Align must be one of the following values: c, center, w, west, e, east")
         self.set_refresh_timer(redraw)
@@ -2846,8 +2832,8 @@ class Sheet(tk.Frame):
     ) -> str | Sheet:
         if align is None:
             return self.RI.align
-        elif self.convert_align(align):
-            self.RI.align = self.convert_align(align)
+        elif convert_align(align):
+            self.RI.align = convert_align(align)
         else:
             raise ValueError("Align must be one of the following values: c, center, w, west, e, east")
         self.set_refresh_timer(redraw)
@@ -2869,7 +2855,7 @@ class Sheet(tk.Frame):
         span = self.span_from_key(*key)
         rows, cols = self.ranges_from_span(span)
         table, index, header = span.table, span.index, span.header
-        align = self.convert_align(align)
+        align = convert_align(align)
         if span.kind == "cell":
             if header:
                 for c in cols:
@@ -3169,7 +3155,7 @@ class Sheet(tk.Frame):
         c1: int,
         r2: int,
         c2: int,
-        type_: str = "cells",
+        type_: Literal["cells", "rows", "columns", "cols"] = "cells",
     ) -> int:
         return self.MT.create_selection_box(r1=r1, c1=c1, r2=r2, c2=c2, type_="columns" if type_ == "cols" else type_)
 
@@ -3179,9 +3165,9 @@ class Sheet(tk.Frame):
 
     def deselect(
         self,
-        row: int | None | str = None,
+        row: int | None | Literal["all"] = None,
         column: int | None = None,
-        cell: tuple | None = None,
+        cell: tuple[int, int] | None = None,
         redraw: bool = True,
     ) -> Sheet:
         self.MT.deselect(r=row, c=column, cell=cell, redraw=False)
@@ -3216,8 +3202,12 @@ class Sheet(tk.Frame):
         self.set_refresh_timer(redraw)
         return self
 
-    def set_all_cell_sizes_to_text(self, redraw: bool = True) -> tuple[list[float], list[float]]:
-        self.MT.set_all_cell_sizes_to_text()
+    def set_all_cell_sizes_to_text(
+        self,
+        redraw: bool = True,
+        width: int | None = None,
+    ) -> tuple[list[float], list[float]]:
+        self.MT.set_all_cell_sizes_to_text(w=width)
         self.set_refresh_timer(redraw)
         return self.MT.row_positions, self.MT.col_positions
 
@@ -4580,8 +4570,9 @@ class Sheet(tk.Frame):
                     )
                 else:
                     self.RI.tree_open_ids.discard(item)
+                    rows = {self.RI.tree_rns[did] for did in self.RI.get_iid_descendants(item, check_open=True)}
                     self.hide_rows(
-                        (self.RI.tree_rns[did] for did in self.RI.get_iid_descendants(item)),
+                        rows,
                         redraw=False,
                         deselect_all=False,
                         data_indexes=True,
@@ -5526,13 +5517,13 @@ class Sheet(tk.Frame):
     ) -> None:
         if isinstance(cells, dict):
             for k, v in cells.items():
-                set_align(self.MT.cell_options, k, self.convert_align(v))
+                set_align(self.MT.cell_options, k, convert_align(v))
         elif cells:
-            align = self.convert_align(align)
+            align = convert_align(align)
             for k in cells:
                 set_align(self.MT.cell_options, k, align)
         else:
-            set_align(self.MT.cell_options, (row, column), self.convert_align(align))
+            set_align(self.MT.cell_options, (row, column), convert_align(align))
         self.set_refresh_timer(redraw)
 
     def align_rows(
@@ -5544,18 +5535,18 @@ class Sheet(tk.Frame):
     ) -> None:
         if isinstance(rows, dict):
             for k, v in rows.items():
-                align = self.convert_align(v)
+                align = convert_align(v)
                 set_align(self.MT.row_options, k, align)
                 if align_index:
                     set_align(self.RI.cell_options, k, align)
         elif is_iterable(rows):
-            align = self.convert_align(align)
+            align = convert_align(align)
             for k in rows:
                 set_align(self.MT.row_options, k, align)
                 if align_index:
                     set_align(self.RI.cell_options, k, align)
         elif isinstance(rows, int):
-            set_align(self.MT.row_options, rows, self.convert_align(align))
+            set_align(self.MT.row_options, rows, convert_align(align))
             if align_index:
                 set_align(self.RI.cell_options, rows, align)
         self.set_refresh_timer(redraw)
@@ -5569,18 +5560,18 @@ class Sheet(tk.Frame):
     ) -> None:
         if isinstance(columns, dict):
             for k, v in columns.items():
-                align = self.convert_align(v)
+                align = convert_align(v)
                 set_align(self.MT.col_options, k, align)
                 if align_header:
                     set_align(self.CH.cell_options, k, align)
         elif is_iterable(columns):
-            align = self.convert_align(align)
+            align = convert_align(align)
             for k in columns:
                 set_align(self.MT.col_options, k, align)
                 if align_header:
                     set_align(self.CH.cell_options, k, align)
         elif isinstance(columns, int):
-            set_align(self.MT.col_options, columns, self.convert_align(align))
+            set_align(self.MT.col_options, columns, convert_align(align))
             if align_header:
                 set_align(self.CH.cell_options, columns, align)
         self.set_refresh_timer(redraw)
@@ -5593,13 +5584,13 @@ class Sheet(tk.Frame):
     ) -> None:
         if isinstance(columns, dict):
             for k, v in columns.items():
-                set_align(self.CH.cell_options, k, self.convert_align(v))
+                set_align(self.CH.cell_options, k, convert_align(v))
         elif is_iterable(columns):
-            align = self.convert_align(align)
+            align = convert_align(align)
             for k in columns:
                 set_align(self.CH.cell_options, k, align)
         elif isinstance(columns, int):
-            set_align(self.CH.cell_options, columns, self.convert_align(align))
+            set_align(self.CH.cell_options, columns, convert_align(align))
         self.set_refresh_timer(redraw)
 
     def align_index(
@@ -5610,13 +5601,13 @@ class Sheet(tk.Frame):
     ) -> None:
         if isinstance(rows, dict):
             for k, v in rows.items():
-                set_align(self.RI.cell_options, k, self.convert_align(v))
+                set_align(self.RI.cell_options, k, convert_align(v))
         elif is_iterable(rows):
-            align = self.convert_align(align)
+            align = convert_align(align)
             for k in rows:
                 set_align(self.RI.cell_options, k, align)
         elif isinstance(rows, int):
-            set_align(self.RI.cell_options, rows, self.convert_align(align))
+            set_align(self.RI.cell_options, rows, convert_align(align))
         self.set_refresh_timer(redraw)
 
     def get_cell_alignments(self) -> dict:
@@ -6381,7 +6372,7 @@ class Dropdown(Sheet):
         width: int | None = None,
         height: int | None = None,
         font: None | tuple[str, int, str] = None,
-        outline_thickness: int = 2,
+        outline_thickness: int = 1,
         values: list[object] = [],
         close_dropdown_window: Callable | None = None,
         search_function: Callable = dropdown_search_function,
@@ -6391,47 +6382,29 @@ class Dropdown(Sheet):
         # False for using r, c
         # "r" for r
         # "c" for c
-        single_index: str | bool = False,
+        single_index: Literal["r", "c"] | bool = False,
     ) -> None:
         Sheet.__init__(
             self,
             parent=parent,
             outline_thickness=outline_thickness,
-            outline_color=outline_color,
-            table_grid_fg=ops.popup_menu_fg,
             show_horizontal_grid=True,
             show_vertical_grid=False,
             show_header=False,
             show_row_index=False,
             show_top_left=False,
-            # alignments other than w for dropdown boxes are broken at the moment
-            align="w",
             empty_horizontal=0,
             empty_vertical=0,
             selected_rows_to_end_of_window=True,
             horizontal_grid_to_end_of_window=True,
             set_cell_sizes_on_zoom=True,
             show_selected_cells_border=False,
-            table_selected_cells_border_fg=ops.popup_menu_fg,
-            table_selected_cells_bg=ops.popup_menu_highlight_bg,
-            table_selected_rows_border_fg=ops.popup_menu_fg,
-            table_selected_rows_bg=ops.popup_menu_highlight_bg,
-            table_selected_rows_fg=ops.popup_menu_highlight_fg,
-            width=width,
-            height=height,
-            font=font if font else self.ops.table_font,
-            table_fg=ops.popup_menu_fg,
-            table_bg=ops.popup_menu_bg,
-            **{k: ops[k] for k in scrollbar_options_keys},
         )
         self.parent = parent
         self.close_dropdown_window = close_dropdown_window
         self.search_function = search_function
         self.arrowkey_RIGHT = arrowkey_RIGHT
         self.arrowkey_LEFT = arrowkey_LEFT
-        self.r = r
-        self.c = c
-        self.row = -1
         self.single_index = single_index
         self.bind("<Motion>", self.mouse_motion)
         self.bind("<ButtonPress-1>", self.b1)
@@ -6443,11 +6416,43 @@ class Dropdown(Sheet):
         self.bind("<Prior>", self.arrowkey_UP)
         self.bind("<Next>", self.arrowkey_DOWN)
         self.bind("<Return>", self.b1)
-        if values:
-            self.values(values)
+        self.reset(r, c, width, height, font, ops, outline_color, align, values)
+
+    def reset(
+        self,
+        r: int,
+        c: int,
+        width: int,
+        height: int,
+        font: tuple[str, int, str],
+        ops: DotDict,
+        outline_color: str,
+        align: str,
+        values: list[object] | None = None,
+    ) -> None:
+        self.r = r
+        self.c = c
+        self.row = -1
+        self.height_and_width(height=height, width=width)
+        self.table_align(align)
+        self.set_options(
+            outline_color=outline_color,
+            table_grid_fg=ops.popup_menu_fg,
+            table_selected_cells_border_fg=ops.popup_menu_fg,
+            table_selected_cells_bg=ops.popup_menu_highlight_bg,
+            table_selected_rows_border_fg=ops.popup_menu_fg,
+            table_selected_rows_bg=ops.popup_menu_highlight_bg,
+            table_selected_rows_fg=ops.popup_menu_highlight_fg,
+            table_selected_box_cells_fg=ops.popup_menu_highlight_bg,
+            table_selected_box_rows_fg=ops.popup_menu_highlight_bg,
+            font=font,
+            table_fg=ops.popup_menu_fg,
+            table_bg=ops.popup_menu_bg,
+            **{k: ops[k] for k in scrollbar_options_keys},
+        )
+        self.values(values, width=width - self.yscroll.winfo_width() - 4)
 
     def arrowkey_UP(self, event: object = None) -> None:
-        self.deselect("all")
         if self.row > 0:
             self.row -= 1
         else:
@@ -6456,7 +6461,6 @@ class Dropdown(Sheet):
         self.select_row(self.row)
 
     def arrowkey_DOWN(self, event: object = None) -> None:
-        self.deselect("all")
         if len(self.MT.data) - 1 > self.row:
             self.row += 1
         self.see(self.row, 0, redraw=False)
@@ -6474,7 +6478,6 @@ class Dropdown(Sheet):
         row = self.identify_row(event, exclude_index=True, allow_end=False)
         if row is not None and row != self.row:
             self.row = row
-            self.deselect("all", redraw=False)
             self.select_row(self.row)
 
     def _reselect(self) -> None:
@@ -6514,7 +6517,12 @@ class Dropdown(Sheet):
             return self.c
         return self.r, self.c
 
-    def values(self, values: list = [], redraw: bool = True) -> None:
+    def values(
+        self,
+        values: list = [],
+        redraw: bool = True,
+        width: int | None = None,
+    ) -> None:
         self.set_sheet_data(
             [[v] for v in values],
             reset_col_positions=False,
@@ -6522,4 +6530,4 @@ class Dropdown(Sheet):
             redraw=False,
             verify=False,
         )
-        self.set_all_cell_sizes_to_text(redraw=redraw)
+        self.set_all_cell_sizes_to_text(redraw=redraw, width=width)

tksheet/text_editor.py

@@ -4,6 +4,9 @@ import tkinter as tk
 from collections.abc import Callable
 from typing import Literal
 
+from .functions import (
+    convert_align,
+)
 from .other_classes import (
     DotDict,
 )
@@ -91,16 +94,15 @@ class TextEditorTkText(tk.Text):
             command=self.undo,
             **menu_kwargs,
         )
-        self.delete(1.0, "end")
-        self.insert(1.0, text)
-        self.yview_moveto(1)
-        self.tag_configure("align", justify=self.align)
+        align = convert_align(align)
         if align == "w":
             self.align = "left"
-        elif align == "center":
-            self.align = "center"
         elif align == "e":
             self.align = "right"
+        self.delete(1.0, "end")
+        self.insert(1.0, text)
+        self.yview_moveto(1)
+        self.tag_configure("align", justify=self.align)
         self.tag_add("align", 1.0, "end")
 
     def _proxy(self, command: object, *args) -> object:

{tksheet-7.1.4.dist-info → tksheet-7.1.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: tksheet
-Version: 7.1.4
+Version: 7.1.5
 Summary: Tkinter table / sheet widget
 Author-email: ragardner <github@ragardner.simplelogin.com>
 License: Copyright (c) 2019 ragardner and open source contributors

tksheet-7.1.5.dist-info/RECORD

@@ -0,0 +1,20 @@
+tksheet/__init__.py,sha256=bzXUATwg31SEbu5F3bS-MFBDpi4MAuMZ0TPh49RAonU,1874
+tksheet/colors.py,sha256=1k06VorynLmnC4FdJg8H4reIA6rXaeXBpdMwXLhN8oc,51594
+tksheet/column_headers.py,sha256=9LOi8-Xr7_h0UlF277VDVg_UWQ3UGVwD9fufwq3SbMU,99272
+tksheet/formatters.py,sha256=DXif00aq9DgFpXwkbiqD86KxtDg0Meop51hLY-KcGNQ,10037
+tksheet/functions.py,sha256=PN2qanv32V4Hg221b-999fEH4yxYNoze925txUP5kA4,39245
+tksheet/main_table.py,sha256=QHFqCkCWkiecHBjbiGBJSJ0SoMp2htXBCpkLIMQEeWI,318511
+tksheet/other_classes.py,sha256=Hjr7c0kD2_880xjtGuFn9gQ-7ED5kSiNahniBeXcf84,13604
+tksheet/row_index.py,sha256=ZPBiKNB5NghU_Q-LEqWrC9-VqaVYj__DodenDSR_oeA,103990
+tksheet/sheet.py,sha256=ho4dGIco8GTCJluFZcJhOJNgnJTA_S_dMm-xU4cJPGo,256866
+tksheet/sheet_options.py,sha256=Vcy4RxTKvf2HM-Yc53ex0lpBe6ATXc_pdx4oLhfjDgU,11906
+tksheet/text_editor.py,sha256=81_IZKrTVa2KIx2cJ4n3cFvFMAwvbHIQYgqtyat-97I,6681
+tksheet/themes.py,sha256=OwUe31NRbosjw3ZoZsMyB8lNVyYin9YcKLhCturi5q8,13398
+tksheet/top_left_rectangle.py,sha256=-2u9GfOvcqhkKwHEtbqdFvXCY3RbvL5k2Sh9l3r_k04,8275
+tksheet/types.py,sha256=IgoEHMbceKpakcZtanxKaKJ4RdCq7UW6EoEIIz5O59k,340
+tksheet/vars.py,sha256=Iukk7-MMT9X7vv0m3nQPKzbp2Iw2Pg1wJEW7js919Mo,2092
+tksheet-7.1.5.dist-info/LICENSE.txt,sha256=ndbcCPe9SlHfweE_W2RAueWUe2k7yudyxYLq6WjFdn4,1101
+tksheet-7.1.5.dist-info/METADATA,sha256=WBm8p-qBsL207lJ6_tznMJE9Vo62iKaZmj-nmyj-UbE,6013
+tksheet-7.1.5.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+tksheet-7.1.5.dist-info/top_level.txt,sha256=my61PXCcck_HHAc9cq3NAlyAr3A3FXxCy9gptEOaCN8,8
+tksheet-7.1.5.dist-info/RECORD,,

tksheet-7.1.4.dist-info/RECORD

@@ -1,20 +0,0 @@
-tksheet/__init__.py,sha256=RGoRjwh2ab3cYtclDJ-EoW9W_wdDZ2jJhWKAeeS7dyQ,1874
-tksheet/colors.py,sha256=1k06VorynLmnC4FdJg8H4reIA6rXaeXBpdMwXLhN8oc,51594
-tksheet/column_headers.py,sha256=CPP2a7LM4KA43ATm997rt3YL-EIhaeUycpVe-ev2fbA,99158
-tksheet/formatters.py,sha256=DXif00aq9DgFpXwkbiqD86KxtDg0Meop51hLY-KcGNQ,10037
-tksheet/functions.py,sha256=7S4cQDIQ-1JqwQCgJSeVUA6bui_CK09zTHrtg2H7UeU,38714
-tksheet/main_table.py,sha256=226s54StK5hBNpNigfO7R-DEuWdtdjCBRyqrJXecz3U,318142
-tksheet/other_classes.py,sha256=Hjr7c0kD2_880xjtGuFn9gQ-7ED5kSiNahniBeXcf84,13604
-tksheet/row_index.py,sha256=oov9iJmjONncmMnzV8dv23dgVKsBX0Fw4YWA28-Xl8o,104187
-tksheet/sheet.py,sha256=z5kW5gdBVQMlwV8G-LI4nknINpGqSbyQ5M9FwX-SUI8,256939
-tksheet/sheet_options.py,sha256=Vcy4RxTKvf2HM-Yc53ex0lpBe6ATXc_pdx4oLhfjDgU,11906
-tksheet/text_editor.py,sha256=7xsEbgIyAWHDBWroh2wk1VeoVftFALlPZC9OANgD6LA,6662
-tksheet/themes.py,sha256=OwUe31NRbosjw3ZoZsMyB8lNVyYin9YcKLhCturi5q8,13398
-tksheet/top_left_rectangle.py,sha256=-2u9GfOvcqhkKwHEtbqdFvXCY3RbvL5k2Sh9l3r_k04,8275
-tksheet/types.py,sha256=IgoEHMbceKpakcZtanxKaKJ4RdCq7UW6EoEIIz5O59k,340
-tksheet/vars.py,sha256=Iukk7-MMT9X7vv0m3nQPKzbp2Iw2Pg1wJEW7js919Mo,2092
-tksheet-7.1.4.dist-info/LICENSE.txt,sha256=ndbcCPe9SlHfweE_W2RAueWUe2k7yudyxYLq6WjFdn4,1101
-tksheet-7.1.4.dist-info/METADATA,sha256=1zV1Vq3e2BEnWQCfQ1I3tu45765I0R7NF88K4pd-2gQ,6013
-tksheet-7.1.4.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-tksheet-7.1.4.dist-info/top_level.txt,sha256=my61PXCcck_HHAc9cq3NAlyAr3A3FXxCy9gptEOaCN8,8
-tksheet-7.1.4.dist-info/RECORD,,