Trying to fix process list update stuck

Author: SystemXFiles

src/constants/threads.py

@@ -1,3 +1,4 @@
 THREAD_SETTINGS = "settings"
 THREAD_TRAY = "tray"
-THREAD_PROCESS_LIST = "process_list"
+THREAD_PROCESS_LIST_DATA = "process_list_data"
+THREAD_PROCESS_LIST_ICONS = "process_list_icons"

src/constants/ui.py

@@ -49,3 +49,6 @@ class EditableTreeviewEvents:
 
 class ScrollableTreeviewEvents:
     SCROLL: Final[str] = "<<Scroll>>"
+
+
+ERROR_TRYING_UPDATE_TERMINATED_TKINTER_INSTANCE = 'main thread is not in main loop'

src/ui/tray.py

@@ -7,11 +7,13 @@
 
 from constants.app_info import APP_NAME_WITH_VERSION, APP_NAME
 from constants.resources import APP_ICON
+from constants.threads import THREAD_SETTINGS
 from constants.ui import OPEN_LOG_LABEL, OPEN_CONFIG_LABEL
 from constants.updates import UPDATE_URL
 from ui.settings import open_settings
 from util.files import open_log_file, open_config_file
 from util.messages import yesno_error_box, show_error, show_info
+from util.scheduler import TaskScheduler
 from util.startup import toggle_startup, is_in_startup
 from util.updates import check_latest_version
 from util.utils import is_portable
@@ -46,6 +48,14 @@ def check_updates():
             webbrowser.open(UPDATE_URL, new=0, autoraise=True)
 
 
+def close_app(item):
+    if TaskScheduler.check_task(THREAD_SETTINGS):
+        show_info(APP_NAME_WITH_VERSION, "Please close the settings window before closing the application.")
+        return
+
+    return item.stop()
+
+
 def init_tray() -> Icon:
     """
     Initializes and returns a system tray icon.
@@ -75,7 +85,7 @@ def init_tray() -> Icon:
         ),
         Menu.SEPARATOR,
 
-        MenuItem('Quit', lambda item: item.stop()),
+        MenuItem('Quit', close_app),
     )
 
     return pystray.Icon("tray_icon", image, APP_NAME, menu)

src/ui/widget/settings/tabs/processes/process_list.py

@@ -5,16 +5,19 @@
 from PIL import ImageTk
 from pydantic import BaseModel
 
+from constants.log import LOG
 from constants.resources import UI_ADD_PROCESS_RULE, UI_ADD_SERVICE_RULE, UI_COPY, UI_SERVICE, \
     UI_PROCESS
+from constants.threads import THREAD_PROCESS_LIST_ICONS
 from constants.ui import CMENU_ADD_PROCESS_RULE_LABEL, CMENU_ADD_SERVICE_RULE_LABEL, COLUMN_WIDTH_WITH_ICON, \
-    CMENU_COPY_LABEL
+    CMENU_COPY_LABEL, ERROR_TRYING_UPDATE_TERMINATED_TKINTER_INSTANCE
 from enums.filters import FilterByProcessType
 from enums.rules import RuleType
 from enums.selector import SelectorType
 from model.process import Process
 from ui.widget.common.treeview.pydantic import PydanticTreeviewLoader
 from ui.widget.common.treeview.sortable import SortableTreeview
+from util.scheduler import TaskScheduler
 from util.ui import load_img, trim_cmenu_label
 from util.utils import get_icon_from_exe
 
@@ -157,10 +160,23 @@ def update_ui(self):
         self._update_process_icons()
 
     def _update_process_icons(self):
-        for row_id in self.get_children():
-            model = self.as_model(row_id)
-            icon = self.get_process_icon(model)
-            self.item(row_id, image=icon)
+        def set_icons(icons):
+            try:
+                for row_id, icon in icons:
+                    self.item(row_id, image=icon)
+            except BaseException as e:
+                if ERROR_TRYING_UPDATE_TERMINATED_TKINTER_INSTANCE not in str(e):
+                    LOG.exception("Update process icons error")
+
+        def get_icons():
+            try:
+                icons = {row_id: self.get_process_icon(self.as_model(row_id)) for row_id in self.get_children()}
+                self.after(0, lambda: set_icons(icons.items()))
+            except BaseException as e:
+                if ERROR_TRYING_UPDATE_TERMINATED_TKINTER_INSTANCE not in str(e):
+                    LOG.exception("Get process icons error")
+
+        TaskScheduler.schedule_task(THREAD_PROCESS_LIST_ICONS, get_icons)
 
     def _get_filtered_data(self, filter_by_type, search_query):
         data = []

src/ui/widget/settings/tabs/processes/process_tab.py

@@ -4,8 +4,8 @@
 
 from constants.log import LOG
 from constants.resources import UI_PROCESS_LIST
-from constants.threads import THREAD_PROCESS_LIST
-from constants.ui import UI_PADDING, ActionEvents
+from constants.threads import THREAD_PROCESS_LIST_DATA
+from constants.ui import UI_PADDING, ActionEvents, ERROR_TRYING_UPDATE_TERMINATED_TKINTER_INSTANCE
 from enums.rules import RuleType
 from enums.selector import SelectorType
 from model.process import Process
@@ -43,9 +43,6 @@ def __init__(self, master: Notebook, process_rules_list: RulesList, service_rule
 
         super().__init__(master)
 
-        self._is_close = False
-        self.bind("<Destroy>", self._on_close)
-
         self._create_process_list()
         self._create_progress_bar()
         self._create_actions()
@@ -74,64 +71,64 @@ def load_from_config(self, config: dict):
         self._refresh()
 
     def _update_process_list(self):
-        filter_by_type = self.actions.filterByType.get_enum_value()
-        search_query = self.actions.search.get().strip().lower()
-
-        self.process_list.set_filter(filter_by_type, search_query)
-        self.process_list.update_ui()
+        try:
+            filter_by_type = self.actions.filterByType.get_enum_value()
+            search_query = self.actions.search.get().strip().lower()
 
-    def _on_close(self, _=None):
-        self._is_close = True
+            self.process_list.set_filter(filter_by_type, search_query)
+            self.process_list.update_ui()
+        except BaseException as e:
+            if ERROR_TRYING_UPDATE_TERMINATED_TKINTER_INSTANCE not in str(e):
+                LOG.exception("Update process list error")
 
     def _refresh(self):
-        main_thread_not_in_mainloop_message = 'main thread is not in main loop'
+        LOG.info("Refreshing process list...")
+
+        def update_process_list():
+            LOG.info("Updating process list...")
+
+            try:
+                self._update_process_list()
+            finally:
+                self._refresh_state()
+
+        def load_data():
+            LOG.info("Loading data...")
+
+            try:
+                self.process_list.set_data(ProcessesInfoService.get_processes(False))
+                self.after(0, update_process_list)
+            except BaseException as e:
+                if ERROR_TRYING_UPDATE_TERMINATED_TKINTER_INSTANCE not in str(e):
+                    LOG.exception("Load data error")
+
+                self._refresh_state()
 
         try:
             self._refresh_state(True)
             self.process_list.clear()
 
-            def load():
-                try:
-                    try:
-                        self.process_list.set_data(ProcessesInfoService.get_processes(False))
-
-                        def do_ui_update():
-                            if self._is_close:
-                                return
-
-                            try:
-                                try:
-                                    self._update_process_list()
-                                finally:
-                                    self._refresh_state()
-                            except BaseException as e:
-                                if str(e) != main_thread_not_in_mainloop_message:
-                                    LOG.exception("Refresh error")
-
-                        if self._is_close:
-                            return
-
-                        self.after(0, do_ui_update)
-                    finally:
-                        self._refresh_state()
-                except BaseException as e:
-                    if str(e) != main_thread_not_in_mainloop_message:
-                        LOG.exception("Refresh error")
-
-            TaskScheduler.schedule_task(THREAD_PROCESS_LIST, load)
-        except:
+            TaskScheduler.schedule_task(THREAD_PROCESS_LIST_DATA, load_data)
+        except BaseException as e:
+            if ERROR_TRYING_UPDATE_TERMINATED_TKINTER_INSTANCE not in str(e):
+                LOG.exception("Refresh error")
+
             self._refresh_state()
-            LOG.exception("Refresh error")
 
     def _refresh_state(self, lock: bool = False):
-        actions = self.actions
-        actions.refresh['state'] = DISABLED if lock else NORMAL
-
-        progress_bar = self._progress_bar
-        if lock:
-            progress_bar.place(relx=0.5, rely=0.5, anchor=CENTER)
-        else:
-            progress_bar.place_forget()
+        try:
+            actions = self.actions
+            actions.refresh['state'] = DISABLED if lock else NORMAL
+
+            progress_bar = self._progress_bar
+
+            if lock:
+                progress_bar.place(relx=0.5, rely=0.5, anchor=CENTER)
+            else:
+                progress_bar.place_forget()
+        except BaseException as e:
+            if ERROR_TRYING_UPDATE_TERMINATED_TKINTER_INSTANCE not in str(e):
+                LOG.exception("Refresh state error")
 
     def save_to_config(self, config: dict):
         pass