Major panes and pages (#1619)

* Plugin settings and loading

* Fixes to database title

* Fix pages failing to close

Author: mrvisscher

activity_browser/__main__.py

@@ -132,7 +132,7 @@ def run_activity_browser_no_launcher():
     modules = ModuleThread()
     modules.run()
 
-    from .ui.widgets import CentralTabWidget
+    from .ui.widgets import ABCentralPagesWidget
     from .app import panes, pages, application, metadata
 
     load_plugins()

activity_browser/app/actions/database/database_open.py

@@ -19,7 +19,7 @@ def run(database_names: list[str]):
 
         for db_name in database_names:
             db_pane = panes.DatabaseProductsPane(app.main_window, db_name)
-            dock_widget = db_pane.getDockWidget(app.main_window)
+            dock_widget = db_pane.getDockWidget()
             dock_widget.resize(dock_widget.width(), app.main_window.height() // 2)
 
             app.main_window.addDockWidget(DatabaseOpen.get_area(), dock_widget)

activity_browser/app/main.py

@@ -8,92 +8,60 @@
 from activity_browser.ui import widgets
 
 
-class MainWindow(QtWidgets.QMainWindow):
-    _instance = None
-    
-    def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super().__new__(cls)
-            cls._instance._initialized = False
-        return cls._instance
-    
+class MainWindow(widgets.ABMainWindow):
 
     def __init__(self, parent=None):
         from activity_browser.app.menu_bar import MenuBar
-
-        if self._initialized:
-            return
-        self._initialized = True
-        
         super().__init__(parent)
 
-        self.setLocale(QtCore.QLocale(QtCore.QLocale.English, QtCore.QLocale.UnitedStates))
         self.setWindowTitle("Activity Browser")
-        self.setDockNestingEnabled(True)
 
         # Layout: extra items outside main layout
         self.menu_bar = MenuBar(self)
         self.setMenuBar(self.menu_bar)
 
-        self.central_widget = widgets.CentralTabWidget(self)
-        self.central_widget.setTabsClosable(True)
+        self.central_widget = widgets.ABCentralPagesWidget(self)
         self.setCentralWidget(self.central_widget)
-        
-        # Initialize all base pages upfront (name -> widget instance)
-        self.base_pages = {}
+
         for page_name, page_class in app.pages.base_pages.items():
-            page_instance = page_class()
-            page_instance.setObjectName(page_name)
-            self.base_pages[page_name] = page_instance
-        
-        # Connect tab close signal
-        self.central_widget.tabCloseRequested.connect(self._on_tab_close_requested)
+            page_instance = page_class(parent=self.central_widget)
+            self.central_widget.addPage(page_instance)
+            self.menu_bar.view_menu.addAction(page_instance.toggleViewAction())
+
+        self.menu_bar.view_menu.addSeparator()
 
         self.connect_signals()
-        self.destroyed.connect(lambda: logger.warning("MainWindow destroyed"))
 
-    def event(self, event):
-        if event.type() == QtCore.QEvent.Type.DeferredDelete:
-            for page in self.base_pages.values():
-                logger.debug(f"Destroying base page {page.__class__.__name__}: {id(page)}")
-                try:
-                    page.deleteLater()
-                except RuntimeError:
-                    # page already deleted
-                    pass
-        return super().event(event)
+    def connect_signals(self):
+        app.signals.project.changed.connect(self.sync)
+        app.signals.settings.changed.connect(self.apply_settings)
 
     def sync(self):
         logger.log("SYNC", f"{self.__class__.__name__}: {id(self)}")
         self.sync_panes()
         self.sync_pages()
 
         self.setWindowTitle(f"Activity Browser - {bd.projects.current}")
+        self.central_widget.setCurrentIndex(0)
 
     def sync_panes(self):
         self.clearPanes()
 
-        dws = []
-
-        # Iterate through the default panes and add them as dock widgets
+        # Iterate through the base panes and add them
+        panes = []
         for pane_name, pane_class in app.panes.base_panes.items():
             pane = pane_class(parent=self)
-            dockwidget = pane.getDockWidget(self)
-            dws.append(dockwidget)
+            panes.append(pane)
+            self.addPane(pane)
 
-            # Add the dock widget to the left dock area
-            self.addDockWidget(QtCore.Qt.LeftDockWidgetArea, dockwidget)
-            # Add the toggle view action to the menu bar
-            self.menu_bar.view_menu.addAction(dockwidget.toggleViewAction())
+            self.menu_bar.view_menu.addAction(pane.toggleViewAction())
 
             # Hide the dock widget if it is marked as hidden
             if pane_name not in app.settings["startup"]["shown_panes"]:
-                dockwidget.hide()
-
-            # Synchronize the pane
-            pane.sync()
+                pane.hide()
 
         # Tabify the dock widgets for better organization
+        dws = [pane.getDockWidget() for pane in panes]
         for dw in dws:
             if dw == dws[0]:
                 continue
@@ -105,118 +73,23 @@ def sync_panes(self):
     def sync_pages(self):
         """
         Synchronizes the central widget pages with the shown_pages setting.
-        
+
         This method shows only those pages that are configured to be shown at startup.
         Pages are pre-initialized and just added/removed from tabs.
         """
         # Get shown pages from settings
         shown_pages = app.settings["startup"].get("shown_pages", [])
-        
+
         # Remove all pages from tabs first
-        while self.central_widget.count() > 0:
-            self.central_widget.removeTab(0)
-        
+        for i in range(self.central_widget.count()):
+            self.central_widget.closeTab(0)
+
         # Add only the pages that should be shown
         for page_name in shown_pages:
-            if page_name in self.base_pages:
-                page_instance = self.base_pages[page_name]
-                # Base pages should show minimize button instead of close
-                self.central_widget.addTab(page_instance, page_name, show_minimize=True)
-    
-    def show_page(self, page_name: str):
-        """
-        Show a page by adding it to the tabs.
-        
-        Args:
-            page_name: The name of the page to show
-        """
-        if page_name not in self.base_pages:
-            return
-        
-        page_widget = self.base_pages[page_name]
-        
-        # Check if page is already in tabs
-        index = self.central_widget.indexOf(page_widget)
-        if index >= 0:
-            # Already shown, just switch to it
-            self.central_widget.setCurrentIndex(index)
-        else:
-            # Add to tabs with minimize button
-            self.central_widget.addTab(page_widget, page_name, show_minimize=True)
-            self.central_widget.setCurrentWidget(page_widget)
-    
-    def hide_page(self, page_name: str):
-        """
-        Hide a page by removing it from the tabs (but not destroying it).
-        
-        Args:
-            page_name: The name of the page to hide
-        """
-        if page_name not in self.base_pages:
-            return
-        
-        page_widget = self.base_pages[page_name]
-        index = self.central_widget.indexOf(page_widget)
-        if index >= 0:
-            self.central_widget.removeTab(index)
-    
-    def toggle_page(self, page_name: str):
-        """
-        Toggle a page shown/hidden.
-        
-        Args:
-            page_name: The name of the page to toggle
-        """
-        if page_name not in self.base_pages:
-            return
-        
-        page_widget = self.base_pages[page_name]
-        index = self.central_widget.indexOf(page_widget)
-        
-        if index >= 0:
-            # Page is shown, hide it
-            self.hide_page(page_name)
-        else:
-            # Page is hidden, show it
-            self.show_page(page_name)
-    
-    def is_page_visible(self, page_name: str) -> bool:
-        """
-        Check if a page is currently visible in the tabs.
-        
-        Args:
-            page_name: The name of the page to check
-            
-        Returns:
-            bool: True if the page is visible, False otherwise
-        """
-        if page_name not in self.base_pages:
-            return False
-        
-        page_widget = self.base_pages[page_name]
-        return self.central_widget.indexOf(page_widget) >= 0
-    
-    def _on_tab_close_requested(self, index: int):
-        """
-        Handle when user clicks the close button on a tab.
-        For base pages, we just hide them instead of destroying them.
-        
-        Args:
-            index: The index of the tab to close
-        """
-        widget = self.central_widget.widget(index)
-        if widget is None:
-            return
-        
-        # Check if this is a base page
-        page_name = widget.objectName()
-        if page_name in self.base_pages:
-            # Just remove from tabs, don't destroy
-            self.central_widget.removeTab(index)
-        else:
-            # For non-base pages, remove and destroy
-            self.central_widget.removeTab(index)
-            widget.deleteLater()
+            if page_name in app.pages.base_pages:
+                page = self.findChild(app.pages.base_pages[page_name])
+                if page:
+                    self.central_widget.addPage(page)
 
     def apply_settings(self, load=False):
 
@@ -243,35 +116,15 @@ def apply_settings(self, load=False):
         # apply pane tab position
         position = app.settings["appearance"]["pane_tab_position"]
         if position == "top":
-            qt_position = QtWidgets.QTabWidget.North
+            qt_position = QtWidgets.QTabWidget.TabPosition.North
         if position == "bottom":
-            qt_position = QtWidgets.QTabWidget.South
+            qt_position = QtWidgets.QTabWidget.TabPosition.South
         if position == "left":
-            qt_position = QtWidgets.QTabWidget.West
+            qt_position = QtWidgets.QTabWidget.TabPosition.West
         if position == "right":
-            qt_position = QtWidgets.QTabWidget.East
+            qt_position = QtWidgets.QTabWidget.TabPosition.East
         self.setTabPosition(QtCore.Qt.DockWidgetArea.AllDockWidgetAreas, qt_position)
 
-    def connect_signals(self):
-        app.signals.project.changed.connect(self.sync)
-        app.signals.settings.changed.connect(self.apply_settings)
-
-    def clearPanes(self):
-        for pane in self.panes():
-            logger.debug(f"Clearing pane {pane.__class__.__name__}: {id(pane)}")
-            pane.deleteLater()
-
-    def panes(self):
-        """
-        Return a list of all panes in the main window.
-        """
-        from activity_browser.ui import widgets
-        QtWidgets.QApplication.processEvents()
-        return self.findChildren(widgets.ABAbstractPane)
-
-    def set_titlebar(self):
-        self.setWindowTitle(f"Activity Browser - {bd.projects.current}")
-
     def dialog_on_exception(self, exception: Exception):
         QtWidgets.QMessageBox.critical(
             self,

activity_browser/app/menu_bar.py

@@ -124,28 +124,28 @@ class ViewMenu(QtWidgets.QMenu):
     def __init__(self, parent=None) -> None:
         super().__init__(parent)
         self.setTitle("&View")
-        
-       
-        # Populate pages
-        self.page_actions = {}
-        for page_name in app.pages.base_pages.keys():
-            action = QtWidgets.QAction(page_name, self)
-            action.setCheckable(True)
-            action.triggered.connect(lambda checked, name=page_name: app.main_window.toggle_page(name))
-            # Update checked state when menu is about to show
-            self.page_actions[page_name] = action
-            self.addAction(action)
-        
-        # Update the checked state when menu is about to show
-        self.aboutToShow.connect(self.update_page_actions)
-        
-        self.addSeparator()
-    
-    def update_page_actions(self):
-        """Update the checked state of page actions based on which pages are visible."""
-        for page_name, action in self.page_actions.items():
-            is_visible = app.main_window.is_page_visible(page_name)
-            action.setChecked(is_visible)
+    #
+    #
+    #     # Populate pages
+    #     self.page_actions = {}
+    #     for page_name in app.pages.base_pages.keys():
+    #         action = QtWidgets.QAction(page_name, self)
+    #         action.setCheckable(True)
+    #         action.triggered.connect(lambda checked, name=page_name: app.main_window.toggle_page(name))
+    #         # Update checked state when menu is about to show
+    #         self.page_actions[page_name] = action
+    #         self.addAction(action)
+    #
+    #     # # Update the checked state when menu is about to show
+    #     # self.aboutToShow.connect(self.update_page_actions)
+    #
+    #     self.addSeparator()
+    #
+    # # def update_page_actions(self):
+    # #     """Update the checked state of page actions based on which pages are visible."""
+    # #     for page_name, action in self.page_actions.items():
+    # #         is_visible = app.main_window.is_page_visible(page_name)
+    # #         action.setChecked(is_visible)
 
 
 class CalculateMenu(QtWidgets.QMenu):

activity_browser/app/pages/activity_details/activity_details.py

@@ -17,7 +17,7 @@
 from .consumers_tab import ConsumersTab
 
 
-class ActivityDetailsPage(QtWidgets.QWidget):
+class ActivityDetailsPage(widgets.ABAbstractPage):
     """
     A widget that displays detailed information about a specific activity.
 

activity_browser/app/pages/calculation_setup/calculation_setup.py

@@ -9,7 +9,7 @@
 from .impact_category_section import ImpactCategorySection
 
 
-class CalculationSetupPage(QtWidgets.QWidget):
+class CalculationSetupPage(widgets.ABAbstractPage):
 
     def __init__(self, cs_name: str, parent=None):
         super().__init__(parent)

activity_browser/app/pages/impact_category_details/impact_category_details.py

@@ -12,14 +12,15 @@
 from .impact_category_header import ImpactCategoryHeader
 
 
-class ImpactCategoryDetailsPage(QtWidgets.QWidget):
+class ImpactCategoryDetailsPage(widgets.ABAbstractPage):
     def __init__(self, name: tuple, parent=None):
         super().__init__(parent)
         self.name = name
         self.impact_category = bd.Method(name)
         self.is_editable = False
 
-        self.setObjectName(" | ".join(name))
+        self.setObjectName("_".join(name))
+        self.setWindowTitle(" | ".join(name))
 
         self.header = ImpactCategoryHeader(self)
 

activity_browser/app/pages/metadatastore.py

@@ -5,7 +5,7 @@
 from activity_browser.app import metadata, signals
 
 
-class MetaDataStorePage(QtWidgets.QWidget):
+class MetaDataStorePage(widgets.ABAbstractPage):
     def __init__(self, parent=None):
         super().__init__(parent)
         self.setObjectName("MetaDataStorePage")