tksheet 7.5.8__tar.gz → 7.5.9__tar.gz

{tksheet-7.5.8/tksheet.egg-info → tksheet-7.5.9}/PKG-INFO

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

{tksheet-7.5.8 → tksheet-7.5.9}/pyproject.toml

@@ -6,7 +6,7 @@ build-backend = "setuptools.build_meta"
 name = "tksheet"
 description = "Tkinter table / sheet and treeview widget"
 readme = "README.md"
-version = "7.5.8"
+version = "7.5.9"
 authors = [{ name = "ragardner", email = "github@ragardner.simplelogin.com" }]
 requires-python = ">=3.8"
 license = {file = "LICENSE.txt"}

{tksheet-7.5.8 → tksheet-7.5.9}/tksheet/__init__.py

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

{tksheet-7.5.8 → tksheet-7.5.9}/tksheet/functions.py

@@ -835,6 +835,17 @@ def move_elements_to(
     )
 
 
+def remove_duplicates_outside_section(strings: list[str], section_start: int, section_size: int) -> list[str]:
+    if section_start == 0 and section_size >= len(strings):
+        return strings
+
+    section_end = section_start + section_size
+    section_set = set(strings[section_start:section_end])
+    print(section_set, section_start, section_size)
+
+    return [s for i, s in enumerate(strings) if (section_start <= i < section_end) or (s not in section_set)]
+
+
 def get_new_indexes(
     move_to: int,
     to_move: Iterable[int],

{tksheet-7.5.8 → tksheet-7.5.9}/tksheet/main_table.py

@@ -1805,7 +1805,7 @@ class MainTable(tk.Canvas):
         create_selections: bool = True,
         event_data: EventDataDict | None = None,
         undo_modification: EventDataDict | None = None,
-        node_change: None | tuple[str, str, int] = None,
+        node_change: None | dict = None,
         manage_tree: bool = True,
     ) -> tuple[dict[int, int], dict[int, int], EventDataDict]:
         self.saved_row_heights = {}
@@ -1965,7 +1965,10 @@ class MainTable(tk.Canvas):
                     # finally, change the span coords
                     span["from_r"], span["upto_r"] = newfrom, newupto
 
-        if (not self.PAR.ops.treeview or not undo_modification) and (move_heights and disp_new_idxs):
+        if not undo_modification and create_selections and self.PAR.ops.treeview:
+            self.PAR.selection_set(*[self._row_index[k].iid for k in data_new_idxs.values()])
+
+        elif not undo_modification and move_heights and disp_new_idxs:
             self.set_row_positions(
                 itr=move_elements_by_mapping_gen(
                     self.get_row_heights(),

{tksheet-7.5.8 → tksheet-7.5.9}/tksheet/row_index.py

@@ -35,6 +35,7 @@ from .functions import (
     num2alpha,
     push_displayed,
     recursive_bind,
+    remove_duplicates_outside_section,
     rounded_box_coords,
     safe_copy,
     stored_event_dict,
@@ -884,7 +885,7 @@ class RowIndex(tk.Canvas):
                 elif (iid := self.event_over_tree_arrow(r, canvasy, event.x)) is not None:
                     if self.MT.selection_boxes:
                         self.select_row(r, ext=True, redraw=False)
-                    self.PAR.item(iid, open_=iid not in self.tree_open_ids)
+                    self.PAR.item(iid, open_=iid not in self.tree_open_ids, undo=False)
             else:
                 self.mouseclick_outside_editor_or_dropdown_all_canvases(inside=True)
             self.b1_pressed_loc = None
@@ -2790,6 +2791,14 @@ class RowIndex(tk.Canvas):
 
         return event_data
 
+    def remove_descendants(self, iids: set[str]) -> tuple[list[int], set[str]]:
+        return (
+            sorted(
+                self.rns[iid] for iid in iids if not any(ancestor in iids for ancestor in self.get_iid_ancestors(iid))
+            ),
+            iids,
+        )
+
     def move_rows_mod_nodes(
         self,
         data_new_idxs: dict[int, int],
@@ -2798,7 +2807,7 @@ class RowIndex(tk.Canvas):
         maxidx: int,
         event_data: EventDataDict,
         undo_modification: EventDataDict | None = None,
-        node_change: tuple[str, str, int] | None = None,
+        node_change: dict | None = None,
     ) -> Generator[tuple[dict[int, int], dict[int, int], dict[str, int], EventDataDict]] | None:
         # data_new_idxs is {old: new, old: new}
         # data_old_idxs is {new: old, new: old}
@@ -2812,97 +2821,84 @@ class RowIndex(tk.Canvas):
 
             elif event_data["moved"]["rows"]:
                 if node_change:
-                    item = node_change[0]
-                    moved_rows = [self.rns[item]]
-                    new_parent = node_change[1]
-                    move_to_index = node_change[2]
-                    # new parent exists
+                    moved_rows, iids = self.remove_descendants(node_change["iids"])
+                    new_parent = node_change["new_par"]
+                    move_to_index = node_change["index"]
                     if new_parent:
                         new_par_cn = self.iid_children(new_parent)
-                        # determine index
+                        len_new_par_cn = len(new_par_cn)
                         if isinstance(move_to_index, int):
-                            move_to_index = min(move_to_index, len(new_par_cn))
+                            move_to_index = min(move_to_index, len_new_par_cn)
                         else:
-                            move_to_index = len(new_par_cn)
-                        # determine insert row
+                            move_to_index = len_new_par_cn
                         if not new_par_cn:
                             insert_row = self.rns[new_parent] + 1
-                        elif move_to_index >= len(new_par_cn):
+                        elif move_to_index >= len_new_par_cn:
                             insert_row = self.rns[new_par_cn[-1]] + self.num_descendants(new_par_cn[-1]) + 1
-                        elif new_parent == self.iid_parent(item):
-                            if move_to_index <= self.PAR.index(item):
-                                # Insert before the sibling at move_to_index
-                                insert_row = self.rns[new_par_cn[move_to_index]]
-                            else:
-                                # Insert after the sibling at move_to_index
-                                insert_row = self.rns[new_par_cn[move_to_index]]
-                                insert_row += 1 + self.num_descendants(new_par_cn[move_to_index])
                         else:
+                            # To get the ids to the proper index and insert row -
+                            # For every iid that is being moved under the same parent but to an
+                            # index further along we have to adjust the insert row and move to index
                             insert_row = self.rns[new_par_cn[move_to_index]]
-                    # no new parent
+                            for iid in iids:
+                                if new_parent == self.iid_parent(iid) and move_to_index > self.PAR.index(iid):
+                                    insert_row += 1 + self.num_descendants(new_par_cn[move_to_index])
+                                    move_to_index += 1
+                                    if move_to_index >= len_new_par_cn:
+                                        break
                     else:
-                        # determine index
                         if isinstance(move_to_index, int):
                             move_to_index = min(move_to_index, sum(1 for _ in self.gen_top_nodes()))
                         else:
                             move_to_index = sum(1 for _ in self.gen_top_nodes())
-                        # determine insert row
                         insert_row = self.PAR._get_id_insert_row(move_to_index, new_parent)
                 else:
-                    # remove any descendants
-                    iids = {self.MT._row_index[r].iid for r in event_data["moved"]["rows"]["data"]}
-                    moved_rows = sorted(
-                        self.rns[iid]
-                        for iid in iids
-                        if not any(ancestor in iids for ancestor in self.get_iid_ancestors(iid))
+                    moved_rows, iids = self.remove_descendants(
+                        {self.MT._row_index[r].iid for r in event_data["moved"]["rows"]["data"]}
                     )
-                    item = self.MT._row_index[moved_rows[0]].iid
                     if isinstance(event_data.value, int):
                         if event_data.value >= len(self.MT.displayed_rows):
                             insert_row = len(self.MT._row_index)
                         else:
                             insert_row = self.MT.datarn(event_data.value)
                         move_to_iid = self.MT._row_index[min(insert_row, len(self.MT._row_index) - 1)].iid
-
                     else:
                         min_from = min(event_data["moved"]["rows"]["data"])
-                        # max_from = max(event_data.moved.rows)
                         min_to = min(event_data["moved"]["rows"]["data"].values())
                         max_to = max(event_data["moved"]["rows"]["data"].values())
                         insert_row = max_to if min_from <= min_to else min_to
                         move_to_iid = self.MT._row_index[insert_row].iid
-
                     move_to_index = self.PAR.index(move_to_iid)
                     new_parent = self.iid_parent(move_to_iid)
-
-                event_data["moved"]["rows"]["data"] = {moved_rows[0]: insert_row}
+                    if any(
+                        self.move_pid_causes_recursive_loop(self.MT._row_index[r].iid, new_parent) for r in moved_rows
+                    ):
+                        event_data["moved"]["rows"], data_new_idxs, data_old_idxs = {}, {}, {}
+                        moved_rows = []
 
                 new_loc_is_displayed = not new_parent or (
                     new_parent and new_parent in self.tree_open_ids and self.PAR.item_displayed(new_parent)
                 )
-                event_data["moved"]["rows"]["displayed"] = {}
+                event_data["moved"]["rows"]["displayed"], disp_new_idxs = {}, {}
 
-                if any(self.move_pid_causes_recursive_loop(self.MT._row_index[r].iid, new_parent) for r in moved_rows):
-                    event_data["moved"]["rows"] = {}
-                    data_new_idxs, data_old_idxs, disp_new_idxs = {}, {}, {}
-
-                else:
+                if moved_rows:
+                    event_data["moved"]["rows"]["data"] = {moved_rows[0]: insert_row}
+                    iids = []
                     for r in moved_rows:
                         iid = self.MT._row_index[r].iid
-                        event_data = self.move_node(
-                            event_data=event_data,
-                            item=iid,
-                            parent=new_parent,
-                            index=move_to_index,
+                        event_data = self.move_node(event_data=event_data, item=iid, parent=new_parent)
+                        iids.append(iid)
+                    if new_parent:
+                        self.iid_node(new_parent).children[move_to_index:move_to_index] = iids
+                        self.iid_node(new_parent).children = remove_duplicates_outside_section(
+                            self.iid_children(new_parent), move_to_index, len(iids)
                         )
-                        move_to_index += 1
                     event_data["moved"]["rows"]["data"] = get_new_indexes(
                         insert_row,
                         event_data["moved"]["rows"]["data"],
                     )
                     data_new_idxs = event_data["moved"]["rows"]["data"]
                     data_old_idxs = {v: k for k, v in data_new_idxs.items()}
-                    disp_new_idxs = event_data["moved"]["rows"]["displayed"]
 
         if data_new_idxs:
             self.MT.move_rows_data(data_new_idxs, data_old_idxs, maxidx)
@@ -2919,27 +2915,16 @@ class RowIndex(tk.Canvas):
 
         yield None
 
-    def move_node(
-        self,
-        event_data: EventDataDict,
-        item: str,
-        parent: str | None = None,
-        index: int = 0,
-    ) -> EventDataDict:
+    def move_node(self, event_data: EventDataDict, item: str, parent: str | None = None) -> EventDataDict:
         # also backs up nodes
         if parent is None:
             parent = self.iid_parent(item)
-
         item_node = self.iid_node(item)
-
-        # new parent is an item
         if parent:
             parent_node = self.iid_node(parent)
             # its the same parent, we're just moving index
             if parent == item_node.parent:
                 event_data = self.copy_nodes((item, parent), event_data)
-                parent_node.children.insert(index, parent_node.children.pop(parent_node.children.index(item)))
-
             else:
                 if item_node.parent:
                     event_data = self.copy_nodes((item, item_node.parent, parent), event_data)
@@ -2947,9 +2932,6 @@ class RowIndex(tk.Canvas):
                     event_data = self.copy_nodes((item, parent), event_data)
                 self.remove_iid_from_parents_children(item)
                 item_node.parent = parent_node.iid
-                parent_node.children.insert(index, item)
-
-        # no new parent
         else:
             if item_node.parent:
                 event_data = self.copy_nodes((item, item_node.parent), event_data)
@@ -2958,7 +2940,7 @@ class RowIndex(tk.Canvas):
             self.remove_iid_from_parents_children(item)
             self.MT._row_index[self.rns[item]].parent = ""
 
-        # last row in mapping is where to start from +1
+        # last row in mapping + 1 is where to start from
         mapping = event_data["moved"]["rows"]["data"]
         row_ctr = next(reversed(mapping.values())) + 1
 
@@ -2966,13 +2948,11 @@ class RowIndex(tk.Canvas):
         if rn not in mapping:
             mapping[rn] = row_ctr
             row_ctr += 1
-
         for did in self.get_iid_descendants(item):
             mapping[self.rns[did]] = row_ctr
             row_ctr += 1
 
         event_data["moved"]["rows"]["data"] = mapping
-
         return event_data
 
     def restore_nodes(self, event_data: EventDataDict) -> None:

{tksheet-7.5.8 → tksheet-7.5.9}/tksheet/sheet.py

@@ -4980,14 +4980,6 @@ class Sheet(tk.Frame):
             self.del_rows(rows, data_indexes=True, undo=undo)
         return self.set_refresh_timer(rows)
 
-    def set_children(self, parent: str, *newchildren) -> Sheet:
-        """
-        Moves everything in '*newchildren' under 'parent'
-        """
-        for iid in unpack(newchildren):
-            self.move(iid, parent)
-        return self
-
     def top_index_row(self, index: int) -> int:
         try:
             return next(self.RI.rns[n.iid] for i, n in enumerate(self.RI.gen_top_nodes()) if i == index)
@@ -5009,9 +5001,9 @@ class Sheet(tk.Frame):
         """
         if item not in self.RI.rns:
             raise ValueError(f"Item '{item}' does not exist.")
-        if parent and parent not in self.RI.rns:
+        elif parent and parent not in self.RI.rns:
             raise ValueError(f"Parent '{parent}' does not exist.")
-        if self.RI.move_pid_causes_recursive_loop(item, parent):
+        elif self.RI.move_pid_causes_recursive_loop(item, parent):
             raise ValueError(f"Item '{item}' causes recursive loop with parent '{parent}.")
         data_new_idxs, disp_new_idxs, event_data = self.MT.move_rows_adjust_options_dict(
             data_new_idxs={},
@@ -5022,7 +5014,45 @@ class Sheet(tk.Frame):
             move_heights=True,
             create_selections=select,
             event_data=None,
-            node_change=(item, parent, index),
+            node_change={"iids": {item}, "new_par": parent, "index": index},
+        )
+        if undo:
+            self.MT.undo_stack.append(stored_event_dict(event_data))
+        self.MT.sheet_modified(event_data, emit_event=emit_event)
+        self.set_refresh_timer()
+        return data_new_idxs, disp_new_idxs, event_data
+
+    def set_children(
+        self,
+        parent: str,
+        *newchildren: str,
+        index: int | None = None,
+        select: bool = True,
+        undo: bool = True,
+        emit_event: bool = False,
+    ) -> Sheet:
+        """
+        Moves everything in '*newchildren' under 'parent'
+        """
+        if parent and parent not in self.RI.rns:
+            raise ValueError(f"Parent '{parent}' does not exist.")
+        iids = set()
+        for iid in unpack(newchildren):
+            if iid not in self.RI.rns:
+                raise ValueError(f"Item '{iid}' does not exist.")
+            elif self.RI.move_pid_causes_recursive_loop(iid, parent):
+                raise ValueError(f"Item '{iid}' causes recursive loop with parent '{parent}.")
+            iids.add(iid)
+        data_new_idxs, disp_new_idxs, event_data = self.MT.move_rows_adjust_options_dict(
+            data_new_idxs={},
+            data_old_idxs={},
+            totalrows=None,
+            disp_new_idxs={},
+            move_data=True,
+            move_heights=True,
+            create_selections=select,
+            event_data=None,
+            node_change={"iids": iids, "new_par": parent, "index": index},
         )
         if undo:
             self.MT.undo_stack.append(stored_event_dict(event_data))

{tksheet-7.5.8 → tksheet-7.5.9/tksheet.egg-info}/PKG-INFO

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