disable UI add/edit/delete UI elements when plan is locked

Disabled only minimum number of elements. Forms can still be opened
and inspected, but form save buttons are disabled.

Author: nmaarnio

arho_feature_template/core/plan_manager.py

@@ -94,7 +94,6 @@
     lock_plan_layers,
     plan_layers_temporarily_unlocked,
     unlock_plan_layers,
-    update_lock_status_if_needed,
 )
 from arho_feature_template.utils.localization_utils import get_localized_text
 from arho_feature_template.utils.misc_utils import (
@@ -152,13 +151,16 @@ class PlanManager(QObject):
     project_loaded = pyqtSignal()
     project_cleared = pyqtSignal()
     plan_identifier_set = pyqtSignal(str)
+    plan_lock_status_changed = pyqtSignal(bool)  # True = now locked, false = now unlocked
 
     def __init__(self):
         super().__init__()
         self.json_plan_path = None
         self.json_plan_outline_path = None
         self.json_plan_matter_path = None
 
+        self.plan_locked = False  # Change this only through `update_lock_status` method
+
         self.plan_feature_libraries = []
         self.regulation_group_libraries = []
 
@@ -300,7 +302,7 @@ def _initialize_plan_feature_libraries(self):
         self.new_feature_dock.initialize_plan_feature_libraries(self.plan_feature_libraries)
 
     def open_manage_plans(self):
-        dialog = ManagePlans(self.regulation_group_libraries)
+        dialog = ManagePlans(self.regulation_group_libraries, self)
         if dialog.exec():
             selected_plan = dialog.selected_plan
             # If the active plan was changed, update state
@@ -318,6 +320,20 @@ def open_import_features_dialog(self):
         )
         self.import_features_form.show()
 
+    def update_lock_status(self, plan_model: Plan):
+        """If input plan is the active plan, applies locked/unlocked state from the given model."""
+        if plan_model.id_ == get_active_plan_id():
+            if plan_model.locked:
+                lock_plan_layers()
+                self.plan_locked = True
+            else:
+                unlock_plan_layers()
+                self.plan_locked = False
+            self.plan_lock_status_changed.emit(plan_model.locked)
+
+            self.regulation_groups_dock.update_lock_status(plan_model.locked)
+            self.new_feature_dock.update_lock_status(plan_model.locked)
+
     @use_wait_cursor
     def update_active_plan_regulation_group_library(self):
         self.active_plan_regulation_group_library = regulation_group_library_from_active_plan()
@@ -348,7 +364,9 @@ def manage_libraries(self):
             self.initialize_libraries()
 
     def _open_regulation_group_form(self, regulation_group: RegulationGroup):
-        regulation_group_form = PlanRegulationGroupForm(regulation_group, self.active_plan_regulation_group_library)
+        regulation_group_form = PlanRegulationGroupForm(
+            regulation_group, self.active_plan_regulation_group_library, not self.plan_locked
+        )
 
         if regulation_group_form.exec_():
             model = regulation_group_form.model
@@ -486,7 +504,7 @@ def edit_plan(self):
                 if plan_id is not None:
                     self.update_active_plan_regulation_group_library()
 
-            update_lock_status_if_needed(plan_model)
+            self.update_lock_status(plan_model)
 
     def edit_plan_matter(self):
         plan_matter_layer = PlanMatterLayer.get_from_project()
@@ -612,6 +630,7 @@ def _plan_feature_geom_digitized(self, feature: QgsFeature):
             self.regulation_group_libraries,
             self.plan_feature_libraries,
             self.active_plan_regulation_group_library,
+            not self.plan_locked,
         )
         if attribute_form.exec_() and save_plan_object(attribute_form.model) is not None:
             self.update_active_plan_regulation_group_library()
@@ -627,6 +646,7 @@ def edit_plan_feature(self, feature: QgsFeature, layer_name: str):
             self.regulation_group_libraries,
             self.plan_feature_libraries,
             self.active_plan_regulation_group_library,
+            not self.plan_locked,
         )
         if attribute_form.exec_() and save_plan_object(attribute_form.model) is not None:
             self.update_active_plan_regulation_group_library()
@@ -700,13 +720,8 @@ def set_active_plan(self, plan_id: str | None) -> None:
                 else:
                     layer.show_all_features()
 
-            plan_feat = PlanLayer.get_feature_by_id(plan_id)
-            if plan_feat:
-                locked = plan_feat["locked"]
-                if locked:
-                    lock_plan_layers()
-                else:
-                    unlock_plan_layers()
+            plan_model = PlanLayer.model_from_feature(PlanLayer.get_feature_by_id(plan_id))
+            self.update_lock_status(plan_model)
         else:
             self.plan_unset.emit()
             for layer in plan_layers:

arho_feature_template/gui/dialogs/manage_plans.py

@@ -18,7 +18,6 @@
 from arho_feature_template.utils.layer_utils import (
     plan_layers_temporarily_unlocked,
     temporary_subset,
-    update_lock_status_if_needed,
 )
 from arho_feature_template.utils.localization_utils import get_localized_text
 from arho_feature_template.utils.misc_utils import (
@@ -31,7 +30,8 @@
 if TYPE_CHECKING:
     from qgis.gui import QgsFilterLineEdit
 
-    from arho_feature_template.core.models import Plan
+    from arho_feature_template.core.models import Plan, RegulationGroupLibrary
+    from arho_feature_template.core.plan_manager import PlanManager
 
 ui_path = resources.files(__package__) / "manage_plans.ui"
 FormClass, _ = uic.loadUiType(ui_path)
@@ -44,7 +44,7 @@ class ManagePlans(QDialog, FormClass):  # type: ignore
     UNLOCKED_ICON: QIcon = QgsApplication.getThemeIcon("unlocked.svg")
 
     @use_wait_cursor
-    def __init__(self, regulation_group_libraries):
+    def __init__(self, regulation_group_libraries: list[RegulationGroupLibrary], plan_manager_ref: PlanManager):
         super().__init__()
         self.setupUi(self)
 
@@ -57,6 +57,7 @@ def __init__(self, regulation_group_libraries):
 
         # INIT
         self.regulation_group_libraries = regulation_group_libraries
+        self.plan_manager_ref = plan_manager_ref
         self.selected_plan = None
         self.plan_layer = PlanLayer.get_from_project()
         self.previously_in_edit_mode = self.plan_layer.isEditable()
@@ -157,7 +158,7 @@ def _on_row_double_clicked(self, item: QTableWidgetItem):
             ):
                 save_plan(edited_plan)
 
-            update_lock_status_if_needed(edited_plan)
+            self.plan_manager_ref.update_lock_status(edited_plan)
             self._update_plan_row(item.row(), edited_plan)
 
     def _on_new_plan_button_clicked(self):

arho_feature_template/gui/dialogs/plan_feature_form.py

@@ -40,6 +40,7 @@ def __init__(
         regulation_group_libraries: list[RegulationGroupLibrary],
         plan_feature_libraries: list[PlanFeatureLibrary] | None = None,
         active_plan_regulation_groups_library: RegulationGroupLibrary | None = None,
+        enable_save: bool = True,  # noqa: FBT001, FBT002
         template_form: bool = False,  # noqa: FBT001, FBT002
     ):
         super().__init__()
@@ -104,6 +105,11 @@ def __init__(
 
         self.button_box.accepted.connect(self._on_ok_clicked)
 
+        if not enable_save:
+            self.button_box.button(QDialogButtonBox.Ok).setEnabled(False)
+            tooltip = "Kaavasuunnitelma on lukittu, kaavakohdetta ei voi muokata."
+            self.button_box.button(QDialogButtonBox.Ok).setToolTip(tooltip)
+
     def _init_save_to_library_button(self) -> None:
         if self.plan_feature_libraries:
             self.plan_object_menu = QMenu()

arho_feature_template/gui/dialogs/plan_regulation_group_form.py

@@ -52,6 +52,7 @@ def __init__(
         self,
         regulation_group: RegulationGroup,
         active_plan_regulation_groups_library: RegulationGroupLibrary | None,
+        enable_save: bool = True,  # noqa: FBT001, FBT002
     ):
         super().__init__()
         self.setupUi(self)
@@ -154,6 +155,11 @@ def __init__(
             self.regulation_group_info_tab.layout().insertLayout(1, layout)
             self.setWindowTitle("Muokkaa kaavamääräysryhmää")
 
+        if not enable_save:
+            self.button_box.button(QDialogButtonBox.Ok).setEnabled(False)
+            tooltip = "Kaavasuunnitelma on lukittu, kaavamääräysryhmää ei voi muokata."
+            self.button_box.button(QDialogButtonBox.Ok).setToolTip(tooltip)
+
     def initialize_regulation_library(self):
         """Initializes the tree menu for regulations."""
         # Map ID to widget to be able to assign parent widgets

arho_feature_template/gui/docks/new_feature_dock.py

@@ -55,6 +55,13 @@ def __init__(self, parent=None) -> None:
 
         TemplateManager.signal_manager.feature_object_added_to_library.connect(self.update_template_list)
 
+    def update_lock_status(self, locked: bool):  # noqa: FBT001
+        self.new_feature_grid.setEnabled(not locked)
+        if locked:
+            self.new_feature_grid.setToolTip("Kaavasuunnitelma on lukittu, kaavakohteita ei voi lisätä.")
+        else:
+            self.new_feature_grid.setToolTip("")
+
     def initialize_plan_feature_libraries(self, plan_feature_libraries: list[PlanFeatureLibrary]):
         self.plan_feature_libraries = plan_feature_libraries
         self.library_selection.clear()

arho_feature_template/gui/docks/plan_features_dock.py

@@ -309,6 +309,7 @@ def _open_form(self, index: QModelIndex):
             plan_feature_libraries=self.plan_manager_ref.plan_feature_libraries,
             regulation_group_libraries=self.plan_manager_ref.regulation_group_libraries,
             active_plan_regulation_groups_library=self.plan_manager_ref.active_plan_regulation_group_library,
+            enable_save=not self.plan_manager_ref.plan_locked,
         )
         if form.exec():
             updated_plan_feature_model = form.model

arho_feature_template/gui/docks/regulation_groups_dock.py

@@ -123,6 +123,8 @@ def __init__(self, parent=None):
 
         self.selection_model = self.table.selectionModel()
 
+        self.plan_locked = False
+
     def initialize(self):
         # Connect feat remove signals for each plan object layer so the linked plan object counts
         # stay updated
@@ -153,6 +155,21 @@ def _connect_signals(self):
         self.add_selected_action.triggered.connect(self.on_add_selected_btn_clicked)
         self.filter_line.textChanged.connect(self._filter_table)
 
+    def update_lock_status(self, locked: bool):  # noqa: FBT001
+        self.plan_locked = locked
+        self.new_btn.setEnabled(not locked)
+        self.delete_btn.setEnabled(not locked)
+        self.modify_selected_features_btn.setEnabled(not locked)
+
+        if locked:
+            self.new_btn.setToolTip("Kaavasuunnitelma on lukittu, kaavamääräysryhmiä ei voi lisätä.")
+            self.delete_btn.setToolTip("Kaavasuunnitelma on lukittu, kaavamääräysryhmiä ei voi poistaa.")
+            self.modify_selected_features_btn.setToolTip("Kaavasuunnitelma on lukittu, kaavakohteita ei voi muokata.")
+        else:
+            self.new_btn.setToolTip("")
+            self.delete_btn.setToolTip("")
+            self.modify_selected_features_btn.setToolTip("")
+
     def _filter_table(self):
         # Set text filter
         search_text = self.filter_line.text()
@@ -341,11 +358,13 @@ def _open_context_menu(self, pos: QPoint):
             self._on_highlight_plan_objects,
         )
         menu.addSeparator()
-        menu.addAction(
+        del_action = menu.addAction(
             QgsApplication.getThemeIcon("mActionDeleteSelected.svg"),
             "Poista kaavamääräysryhmä" if nr_of_selected_groups == 1 else "Poista valitut kaavamääräysryhmät",
             self.on_delete_btn_clicked,
         )
+        del_action.setEnabled(not self.plan_locked)
+
         menu.exec_(self.table.viewport().mapToGlobal(pos))
 
     def _on_select_plan_objects(self):

arho_feature_template/plugin.py

@@ -475,6 +475,7 @@ def initGui(self) -> None:  # noqa N802
         self.plan_manager.plan_unset.connect(self.on_active_plan_unset)
         self.plan_manager.project_loaded.connect(self.on_project_loaded)
         self.plan_manager.project_cleared.connect(self.on_project_cleared)
+        self.plan_manager.plan_lock_status_changed.connect(self.on_plan_lock_status_changed)
         if SettingsManager.get_data_exchange_layer_enabled():
             self.plan_manager.plan_identifier_set.connect(self.update_ryhti_buttons)
         self.plan_manager.plan_identifier_set.connect(self.validation_dock.on_permanent_identifier_set)
@@ -575,6 +576,9 @@ def on_project_cleared(self):
         for action in self.plan_matter_depending_actions:
             action.setEnabled(False)
 
+    def on_plan_lock_status_changed(self, locked: bool):  # noqa: FBT001
+        self.import_features_action.setEnabled(not locked)
+
     def unload(self) -> None:
         """Removes the plugin menu item and icon from QGIS GUI."""
         # Handle signals

arho_feature_template/utils/layer_utils.py

@@ -2,12 +2,11 @@
 
 from qgis.core import QgsVectorLayer
 
-from arho_feature_template.core.models import Plan
 from arho_feature_template.project.layers.plan_layers import PlanLayer, plan_layers
-from arho_feature_template.utils.misc_utils import get_active_plan_id
 
 
 def lock_plan_layers():
+    """NOTE: Should be used from PlanManager if not temporary, otherwise PlanManager.plan_locked gets out of sync."""
     for layer in plan_layers:
         vlayer = layer.get_from_project()
         if vlayer is None:
@@ -20,6 +19,7 @@ def lock_plan_layers():
 
 
 def unlock_plan_layers(start_editing_plan_layer: bool = True):  # noqa: FBT001, FBT002
+    """NOTE: Should be used from PlanManager if not temporary, otherwise PlanManager.plan_locked gets out of sync."""
     for layer in plan_layers:
         vlayer = layer.get_from_project()
         if vlayer is None:
@@ -31,15 +31,6 @@ def unlock_plan_layers(start_editing_plan_layer: bool = True):  # noqa: FBT001,
         PlanLayer.get_from_project().startEditing()
 
 
-def update_lock_status_if_needed(edited_plan_model: Plan):
-    """If edited plan is the active plan, applies locked/unlocked state from the given model."""
-    if edited_plan_model.id_ == get_active_plan_id():
-        if edited_plan_model.locked:
-            lock_plan_layers()
-        else:
-            unlock_plan_layers()
-
-
 @contextmanager
 def plan_layers_temporarily_unlocked():
     """Ensures layers are editable and returns to locked afterwards if they were locked before."""