[Question] How to move selected row in a Tree element up and down

[maslyankov]

Type of Issues (Enhancement, Error, Bug, Question)

Question

Operating System

Python version

3.6

PySimpleGUI Port and Version

Ports = tkinter, Qt, WxPython, Web

PySimpleGUI Version: 4.29.0

tkinter version:

You can get these by adding this to the top of your file and running it:

import PySimpleGUI as sg

print(sg)             # Location of your PySimpleGUI.py file
print(sg.version)     # PySimpleGUI version number
print(sg.tclversion_detailed)   # tkinter detailed version number (in PySimpleGUI version 4.29.0+)
print(sg.sys.version) # Python version number

The tkinter version number can be obtained using above code in version 4.29.0+. If your code is prior:

print(sg.tkinter.Tcl().eval('info patchlevel'))

Your Experience Levels In Months or Years

1 Python programming experience
5 Programming experience overall
Have used another Python GUI Framework (tkinter, Qt, etc) previously (yes/no is fine)?
PythonWX

You have completed these steps:

• Read instructions on how to file an Issue
• Searched through main docs http://www.PySimpleGUI.org for your problem
• Searched through the readme for your specific port if not PySimpleGUI (Qt, WX, Remi)
• Looked for Demo Programs that are similar to your goal http://www.PySimpleGUI.com
• Note that there are also Demo Programs under each port on GitHub
• Run your program outside of your debugger (from a command line)
• Searched through Issues (open and closed) to see if already reported
• [] Try again by upgrading your PySimpleGUI.py file to use the current one on GitHub. Your problem may have already been fixed but is not yet on PyPI.

Description of Problem / Question / Details

How to move selected row in a Tree element up and down?

Code To Duplicate

A short program that isolates and demonstrates the problem (i.e. please don't paste a link to your 400 line program.... instead paste your 10 line program in full).

Yes, it is a pain to narrow down problems, but it's part of the debugging process. Help me help you by providing something that can be executed so that work on getting you a fix or a workaround can immediately begin.

This pre-formatted code block is all set for you to paste in your bit of code:

import PySimpleGUI as sg

## Paste your code here

[jason990420]

As I known, PySimpleGUI provide only static layout, and there's no way to move selected row(s) up or down in Tree element.

Anyway, I had been built this function with some tkinter code by myself for it.
It is very complex if tree with multi-layers and movement between any nodes.

To do it,

• Specify what movement allowed between nodes.
• Move the node from parent node to another new parent node.
  • Remove node from children list of prarent node
  • Insert node into children list of new parent node
  • Change parent node of node to new parent node
• Update Tree element.
• Row selected and see.

Here's my code for your reference.

class Tree(sg.Tree):
    """
    Tree for node name shown only, with load from dictionary, dump tree to
    dictionary, delete node, rename node, move node up, move node down,
    where the selection, set node text, read node text, set node value,
    read node text, set select, hide_header, sort nodes

    ** Must call hide_tree(window) after window finalized !!!
    """
    def __init__(self, column_width=30, font=('Courier New', 12), key='TREE',
                 text_color='black', background_color='white', num_rows=25,
                 row_height=28):
        """
        Tree is a subclass of sg.Tree with more methods and functions.
        : Parameters
          column_width - int, width of tree in chars.
          font - font for character style in tree view.
          key - str, tree reference key in PySimpleGUI.
          text_color - color, text color.
          background_color - coor, background color.
          num_rows - int, height of tree view in lines.
          row_height - int, height of line in pixels.
        : Return
          Instance of Tree
        """
        self.key = key
        self.text = None
        self.list = []
        self.treedata = sg.TreeData()
        self._init(lines=num_rows, width=column_width, row_height=row_height,
                   text=text_color, background=background_color, font=font,
                   key=key)

    def delete_all_nodes(self):
        """
        Delete all nodes in Tree.
        """
        keys = [tag.key for tag in self.treedata.tree_dict[''].children]
        self.delete_nodes(keys)

    def delete_node(self, key, update=True):
        """
        Delete node 'key' from tree. After delete, selection will move up.
        : Parameters
          key - str, node key tp remove
        """
        self._all_nodes()
        if key and key in self.list:
            pre_key = self._previous_key(key)
            node = self.treedata.tree_dict[key]
            self.treedata.tree_dict[node.parent].children.remove(node)
            node_list = [node]
            while node_list != []:
                temp = []
                for item in node_list:
                    temp += item.children
                    del self.treedata.tree_dict[item.key]
                    del item
                node_list = temp
            if update:
                self.tree.update(values=self.treedata)
                self.select(pre_key)

    def delete_nodes(self, keys):
        """
        Delete all nodes with key in keys.
        : Parameters
          keys - sequence of key
        """
        for key in keys:
            self.delete_node(key, update=False)
        self.tree.update(values=self.treedata)
        self.select('0')

    def dump_tree(self):
        """
        Save treedata to dictionary
        Dictionary pairs in key: [parent, children, text, values]
        : Return
          dictionary for treedata
        """
        dictionary = {}
        for key, node in self.treedata.tree_dict.items():
            children = [n.key for n in node.children]
            dictionary[key]   = [node.parent, children, node.text, node.values]
        return dictionary

    def get_text(self, key):
        """
        Get node name
        : Parameters
          key - str, key of node
        : Return
          str, name text of node
        """
        return self.treedata.tree_dict[key].text

    def get_value(self, key):
        """
        Get values[0] of node.
        : Parameters
          key - str, key of node
        : Return
          str, value of node
        """
        values = self.treedata.tree_dict[key].values
        return values[0] if values else ''

    def hide_header(self, window):
        """
        Hide header of tree.
        : Parameters
          window - instance of sg.Window
        """
        self.tree = window[self.key]
        self.tree.Widget.configure(show='tree')

    def insert_node(self, parent, name, text, update=True):
        """
        Insert a new node under parent, by name and text
        : Parameters
          parent - str, key of parent node, '' for root.
          name - str, name of new node
          text - str, value of node
          update - bool, True to update treedata into tree.
        : return
          None
        """
        if name:
            key = self._new_key()
            self.treedata.Insert(parent, key, name, [text])
            if update:
                self.tree.update(values=self.treedata)

    def load_tree(self, dictionary):
        """
        Load dcitionary into self.treedata and update self.tree
        : Parameters
          dictionary - data for treedata in Tree.
            Dictionary pairs in key: [parent, children, text, values]
            parent, children are key of nodes, values in [str]
        """
        children = dictionary[''][1]
        table = {'':''}
        while children != []:
            temp = []
            for child in children:
                node = dictionary[child]
                table[child] = self._new_key()
                self.treedata.Insert(
                    table[node[0]], table[child], node[2], node[3])
                temp += node[1]
            children = temp
        self.tree.update(values=self.treedata)

    def move_node_up(self, key):
        """
        Move node up in tree structure, not position only.
        : Parameters
          key - str, key of node
        """
        if not key:
            return
        node = self.treedata.tree_dict[key]
        if not key:
            return
        pre = self._previous_key(key)
        pre_node = self.treedata.tree_dict[pre]
        if not pre:
            return
        if pre == node.parent:
            pre_parent_node = self.treedata.tree_dict[pre_node.parent]
            index = pre_parent_node.children.index(pre_node)
            pre_parent_node.children = (pre_parent_node.children[:index] +
                [node] + pre_parent_node.children[index:])
            self.treedata.tree_dict[node.parent].children.remove(node)
            node.parent = pre_parent_node.key
        else:
            if node.parent == pre_node.parent:
                parent_node = self.treedata.tree_dict[node.parent]
                index = parent_node.children.index(pre_node)
                parent_node.children.remove(node)
                parent_node.children = (parent_node.children[:index] +
                    [node] + parent_node.children[index:])
            else:
                pre_parent_node = self.treedata.tree_dict[pre_node.parent]
                pre_parent_node.children.append(node)
                self.treedata.tree_dict[node.parent].children.remove(node)
                node.parent = pre_parent_node.key
        self.tree.update(values=self.treedata)
        self.select(key)

    def move_node_down(self, key):
        """
        Move node down in tree structure, not position only.
        : Parameters
          key - str, key of node
        """
        if not key:
            return
        nxt = self._next_not_children(key)
        if not nxt:
            return
        node = self.treedata.tree_dict[key]
        nxt_node = self.treedata.tree_dict[nxt]
        if nxt_node.children == []:
            self.treedata.tree_dict[node.parent].children.remove(node)
            parent_node = self.treedata.tree_dict[nxt_node.parent]
            index = parent_node.children.index(nxt_node)
            parent_node.children = (parent_node.children[:index+1] +
                [node] + parent_node.children[index+1:])
            node.parent = nxt_node.parent
        else:
            self.treedata.tree_dict[node.parent].children.remove(node)
            nxt_node.children = [node] + nxt_node.children
            node.parent = nxt_node.key
        self.tree.update(values=self.treedata)
        self.select(key)

    def rename(self, key, text):
        """
        Rename node text
        : Parameters
          key - str, key of node
          txt - str, new text for node
        """
        if key and text:
            self.set_text(key, text)

    def search(self, text=None, mode='New'):
        """
        Search name in tree.
        :Parameters
          text - str, name of node.
          next - str, 'New' for new search, 'Previous' for previous node,
            'Next' for next node.
        :Return
          key of node, None if not found.
        """
        if len(self.treedata.tree_dict) < 2 or (mode=='New' and not text):
            return None
        self._all_nodes()
        where = self.where()
        index = self.list.index(where) if where else -1
        if mode == 'New':
            self.text = text.lower()
            return self._search_next_node(-1)
        if mode == 'Previous':
            return self._search_previous_node(index)
        elif mode == 'Next':
            return self._search_next_node(index)
        return None

    def select(self, key=''):
        """
        Move the selection of node to node key.
        : Parameters
          key - str, key of node.
        """
        iid = self._key_to_id(key)
        if iid:
            self.tree.Widget.see(iid)
            self.tree.Widget.selection_set(iid)

    def set_text(self, key, text):
        """
        Set new node name
        : Parameters
          key - str, key of node.
          text - str, new name of node.
        """
        self.treedata.tree_dict[key].text = text
        self.tree.update(key=key, text=text)

    def set_value(self, key, text):
        """
        Set values[0] of node to new value 'text'.
        : Parameters
          key - str, key of node.
          text - str, new value of node.
        """
        self.treedata.tree_dict[key].values[0] = text

    def sort_tree(self, func=None):
        """
        Sort children list of all nodes by node name.
        : Parameter
          func - function name to process text for sorting key.
            def func(text):
                ...
                return new_text
            called by tree.sort_tree(func)
        : Return
          None, result upadted into Tree.
        """
        pre_select_key = self.where()
        for key, node in self.treedata.tree_dict.items():
            children = node.children
            if func:
                node.children = sorted(
                    children, key=lambda child: func(child.text))
            else:
                node.children = sorted(children, key=lambda child: child.text)
        self.tree.update(values=self.treedata)
        self.select(pre_select_key)

    def where(self):
        """
        Get where the selection
        : Return
          str, key of node, '' for root node
        """
        item = self.tree.Widget.selection()
        return '' if len(item) == 0 else self.tree.IdToKey[item[0]]

    def _all_nodes(self, parent='', new=True):
        """
        Get all keys of nodes in list order.
        : Parameter
          parent - str, key of starting node.
          new - True for begiinning of search.
        : Return
          None, result in self.list
        """
        if new:
            self.list = []
        children = self.treedata.tree_dict[parent].children
        for child in children:
            self.list.append(child.key)
            self._all_nodes(parent=child.key, new=False)

    def _init(self, lines=25, width=30, row_height=28, text='black',
              background='white', font=('Courier New', 12), key='TREE'):
        """
        Initialization for sg.Tree
        : Parameter
          lines - int, lines of tree view
          width - int, width of tree view in chars.
          row_height - int, line height of tree view in pixels.
          text - color for text.
          background - color of background.
          font - font of text
          key - str, key of element in PySimpleGUI.
        : return
          None
        """
        super().__init__(data=self.treedata, headings=['Notes',], pad=(0, 0),
        show_expanded=False, col0_width=width, auto_size_columns=False,
        visible_column_map=[False,], select_mode=sg.TABLE_SELECT_MODE_BROWSE,
        enable_events=True, text_color=text, background_color=background,
        font=font, num_rows=lines, row_height=row_height, key=key)

    def _key_to_id(self, key):
        """
        Convert PySimplGUI element key to tkinter widget id.
        : Parameter
          key - str, key of PySimpleGUI element.
        : Return
          id - int, id of tkinter widget
        """
        for k, v in self.tree.IdToKey.items():
            if v == key:
                return k
        return None

    def _new_key(self):
        """
        Find a unique Key for new node, start from '1' and not in node list.
        : Return
          str, unique key of new node.
        """
        i = 0
        while True:
            i += 1
            if str(i) not in self.treedata.tree_dict:
                return str(i)

    def _previous_key(self, key):
        """
        Find the previous node key in tree list.
        : Parameter
          key - str, key of node.
        : Return
          str, key of previous node.
        """
        self._all_nodes('')
        index = self.list.index(key)
        result = '' if index==0 else self.list[index-1]
        return result

    def _next_not_children(self, key):
        """
        Find next node key, where node are not children of node 'key'.
        : Parameter
          key - str, key of node.
        : Return
          str, key of next node.
        """
        self._all_nodes('')
        index = self.list.index(key) + 1
        while index < len(self.list):
            parent = []
            p = self.treedata.tree_dict[self.list[index]].parent
            while True:
                parent.append(p)
                p = self.treedata.tree_dict[p].parent
                if p == '': break
            if key in parent:
                index += 1
            else:
                return self.list[index]
        return None

    def _search_next_node(self, index):
        """
        Search next one node.
        :Return
          key of next node, None for not found.
        """
        if not self.text:
            return None
        length = len(self.list)
        for i in range(index+1, length):
            key = self.list[i]
            if self.text in self.treedata.tree_dict[key].text.lower():
                return key
        return None

    def _search_previous_node(self, index):
        """
        Search previous one node.
        :Return
          key of previous node, None for not found.
        """
        if not self.text:
            return None
        for i in range(index-1, -1, -1):
            key = self.list[i]
            if self.text in self.treedata.tree_dict[key].text.lower():
                return key
        return None

Note: Not only function for movement of node, also some other functions required for Tree node.

[jason990420]

It will be very simple for only one layer Tree, but tkinter code required.
Just change the order of children list in root node '', then update tree.

For example,

import PySimpleGUI as sg


def hide_header(tree):
    tree.Widget.configure(show='tree')

def key_to_id(key):
    for k, v in tree.IdToKey.items():
        if v == key:
            return k
    return None

def select(key=''):
    iid = key_to_id(key)
    if iid:
        tree.Widget.see(iid)
        tree.Widget.selection_set(iid)

def where():
    item = tree.Widget.selection()
    return '' if len(item) == 0 else tree.IdToKey[item[0]]

def move_up():
    key =  where()
    if key == '':
        return
    node = treedata.tree_dict[key]
    parent_node = treedata.tree_dict[node.parent]
    index = parent_node.children.index(node)
    if index != 0:
        parent_node.children[index-1], parent_node.children[index] = (
            parent_node.children[index], parent_node.children[index-1])
    tree.update(values=treedata)
    select(key)

def move_down():
    key = where()
    if key == '':
        return
    node = treedata.tree_dict[key]
    parent_node = treedata.tree_dict[node.parent]
    index = parent_node.children.index(node)
    if index != len(parent_node.children)-1:
        parent_node.children[index+1], parent_node.children[index] = (
            parent_node.children[index], parent_node.children[index+1])
    tree.update(values=treedata)
    select(key)

fruits = [
    "Apple", "Banana", "Cherry", "Durian", "Elderberry", "Guava", "Jackfruit",
    "Kiwi", "Lemon", "Mango", "Orange", "Papaya", "Strawberry", "Tomato",
    "Watermelon",
]

treedata = sg.TreeData()
for i, fruit in enumerate(fruits):
    treedata.Insert('', i, fruit, values=[f'Fruit {i:0>2d}'])

layout = [
    [sg.Button('Move Up'), sg.Button('Move Down')],
    [sg.Tree(data=treedata, key='TREE', headings=['Nothing'],
        select_mode=sg.TABLE_SELECT_MODE_BROWSE)],
]

window = sg.Window('Tree', layout, finalize=True)
tree = window['TREE']
hide_header(tree)

while True:

    event, values = window.read()
    print(event, values)
    if event == sg.WINDOW_CLOSED:
        break
    elif event == 'Move Up':
        move_up()
    elif event == 'Move Down':
        move_down()

window.close()

[maslyankov]

Looks good, yes. How would you move parent nodes along with their children? That’s something I need more than moving children. Thank you!

[jason990420]

After parent node moved, children nodes also moved. Children nodes are referenced to parent node.

[jason990420]

Code here to build a demo treedata only

import PySimpleGUI as sg

class Tree_Data():
    def __init__(self):
        self.treedata = sg.TreeData()

    def new_key(self):
        i = 0
        while i in self.treedata.tree_dict:
            i += 1
        return i

    def insert(self, data):
        for i, first in enumerate(data):
            key = self.new_key()
            self.treedata.Insert('', key, first[0], values=[])
            for j, second in enumerate(first[1]):
                self.treedata.Insert(key, self.new_key(), second, values=[])

tree_data = Tree_Data()

data = [
    ['Fruit',     ['Apple', 'Mongo']],
    ['Seasoning', ['Cat', 'Dog', 'Tiger']],
    ['Meat', ['Pork', 'Beef', 'Fish']],
    ['Vegetable', ['Broccoli', 'Cabbages', 'Mushrooms']],
]

tree_data.insert(data)

>>> tree_data.treedata
 : root
    0 : Fruit
        1 : Apple
        2 : Mongo
    3 : Seasoning
        4 : Cat
        5 : Dog
        6 : Tiger
    7 : Meat
        8 : Pork
        9 : Beef
        10 : Fish
    11 : Vegetable
        12 : Broccoli
        13 : Cabbages
        14 : Mushrooms

How to deal with the movement for multi-layer tree ? replied as in my first reply to your issue.

First, you have to define the rules about what movement is legal, like

• 2 (Mongo) can be moved only under 0 (Fruit), or also OK to under 0/3/7/11, or root ?
• 7 (Meat) can be moved only under root, or also OK to under 0/3/7/11 ?

Then, you have to write methods move_up, move_down by yourself for your requirements.

treedata.tree_dict keep all nodes

>>> tree_data.treedata.tree_dict
{0: <PySimpleGUI.PySimpleGUI.TreeData.Node object at 0x0000000001748550>,
 1: <PySimpleGUI.PySimpleGUI.TreeData.Node object at 0x00000000017485E0>,
 2: <PySimpleGUI.PySimpleGUI.TreeData.Node object at 0x00000000017489D0>,
 3: <PySimpleGUI.PySimpleGUI.TreeData.Node object at 0x00000000017485B0>,
 4: <PySimpleGUI.PySimpleGUI.TreeData.Node object at 0x0000000001748A30>,
 5: <PySimpleGUI.PySimpleGUI.TreeData.Node object at 0x00000000017487F0>,
 6: <PySimpleGUI.PySimpleGUI.TreeData.Node object at 0x0000000001748A60>,
 7: <PySimpleGUI.PySimpleGUI.TreeData.Node object at 0x0000000001748A00>,
 8: <PySimpleGUI.PySimpleGUI.TreeData.Node object at 0x0000000001748A90>,
 9: <PySimpleGUI.PySimpleGUI.TreeData.Node object at 0x00000000017488B0>,
 10: <PySimpleGUI.PySimpleGUI.TreeData.Node object at 0x0000000001748AC0>,
 11: <PySimpleGUI.PySimpleGUI.TreeData.Node object at 0x0000000001748850>,
 12: <PySimpleGUI.PySimpleGUI.TreeData.Node object at 0x0000000001748AF0>,
 13: <PySimpleGUI.PySimpleGUI.TreeData.Node object at 0x0000000001748670>,
 14: <PySimpleGUI.PySimpleGUI.TreeData.Node object at 0x0000000001748B20>,
 '': <PySimpleGUI.PySimpleGUI.TreeData.Node object at 0x000000000172FE50>}

For key 7: Meat, you can find the relationship among itself, parent and children. Then, to build your methods of movement or others. Important attributions shown as following.

>>> n7 = tree_data.treedata.tree_dict[7]
>>> n7.parent, n7.key, n7.text, n7.children, n7.values, n7.icon
('',  7,  'Meat',
 [<PySimpleGUI.PySimpleGUI.TreeData.Node object at 0x0000000001748A90>,
  <PySimpleGUI.PySimpleGUI.TreeData.Node object at 0x00000000017488B0>,
  <PySimpleGUI.PySimpleGUI.TreeData.Node object at 0x0000000001748AC0>],
 [], None)

The position is decided by parent, and order in children list of parent node. For any action to change the content of treedata, you have to handle the relationship between parent and child, also the order in children list. After treedata re-organized, update Tree element.

Anyway, the above content is beyond the scope of the Simple principle of PySimpleGUI. In my point of view, it is impossible to provide any dynamic methods for Treedata/Tree at this moment, the same for Table element.

[PySimpleGUI]

Oh wow! This is a lot to digest. I'm coming in fresh.....

I think Jason's last comment may be a great summary of the situation with nearly all data structures in PySimpleGUI

Anyway, the above content is beyond the scope of the Simple principle of PySimpleGUI. In my point of view, it is impossible to provide any dynamic methods for Treedata/Tree at this moment, the same for Table element.

The data structures for Menus, Trees, Tables, etc, are all meant to communicate, in a 1-way direction, information that is to be displayed to the user in the GUI. They were not designed, at least initially, to be modified using methods provided by PySimpleGUI. The assumption was that manipulations of data was a user-responsibility. How a user wishes to store and manipulate their data is entirely up to the user's code. It's the process of communicating the information to PySimpleGUI that the data structures defined by PySimpleGUI come into play.

I can understand, totally, the point of view that providing ways of manipulating these data structures would be helps or should be part of PySimpleGUI already.

One of the simplest cases that has recently been discussed is disabling a menu item. I've been giving this a lot of thought and I Still don't quite know what direction I will take on it. In theory, it shouldn't be very difficult for me to write code to manipulate the underlying Menu data structure, if provided a key. I would take that key and search through the menu definition, and modify the entry to show that it's disabled.

I'm choosing this Menu example because it's one of the easiest of this set of problems, modifying the GUI data structures. Trees are likely the most complex of all of the PySimpleGUI data structures. The others are all based directly from Python built-in data types (i.e. lists and dictionaries).

I don't have an opinion at the moment on this, nor do I have the solution. Jason seems to have provided one, at least for this case. And, wow, once again a big thank you to @jason990420 for coming up with a solution.

In the short-term, it's a moot point as providing interfaces to manipulate these data structures isn't something that's going to make it onto the priority list for some time.

[maslyankov]

Thank you so much for your help! Really appreciate it! I managed to accomplish my goal. Could you give me a hint on how to expand and collapse all the nodes in a tree (with a method/button)? Thanks in advance!

[jason990420]

Here for your reference,

import PySimpleGUI as sg


class Tree_Data():

    def __init__(self):
        self.treedata = sg.TreeData()

    def new_key(self):
        i = 0
        while i in self.treedata.tree_dict:
            i += 1
        return i

    def insert(self, data):
        for i, first in enumerate(data):
            key = self.new_key()
            self.treedata.Insert('', key, first[0], values=[])
            for j, second in enumerate(first[1]):
                self.treedata.Insert(key, self.new_key(), second, values=[])

def key_to_id(key):
    for k, v in tree.IdToKey.items():
        if v == key:
            return k
    return None

def expand_all():
    for key in tree_data.treedata.tree_dict:
        tree.Widget.item(key_to_id(key), open=True)

def collapse_all():
    for key in tree_data.treedata.tree_dict:
        tree.Widget.item(key_to_id(key), open=False)

sg.theme('dark')
sg.set_options(font=('Helvetica', 10))
tree_data = Tree_Data()
data = [
    ['Fruit',     ['Apple', 'Mongo']],
    ['Seasoning', ['Cat', 'Dog', 'Tiger']],
    ['Meat', ['Pork', 'Beef', 'Fish']],
    ['Vegetable', ['Broccoli', 'Cabbages', 'Mushrooms']],
]
tree_data.insert(data)

layout = [
    [sg.Tree(data=tree_data.treedata, headings=['Notes',], show_expanded=False,
     col0_width=20, select_mode=sg.TABLE_SELECT_MODE_BROWSE, enable_events=True,
     visible_column_map=[False,], key='TREE')],
    [sg.Button('Expand'), sg.Button('Collapse')]
]
window = sg.Window('TREE', layout, finalize=True)
tree = window['TREE']
tree.Widget.configure(show='tree')  # Hide header

while True:

    event, values = window.read()
    if event == sg.WINDOW_CLOSED:
        break
    elif event == 'Expand':
        expand_all()
    elif event == 'Collapse':
        collapse_all()

window.close()