Add "Add Feature Collection" button, buildout menu tooling

ee_plugin/ee_plugin.py

@@ -21,6 +21,7 @@
 import ee
 
 from . import provider, config, ee_auth, utils
+from .ui.forms import add_feature_collection
 
 
 PLUGIN_DIR = os.path.dirname(__file__)
@@ -92,8 +93,7 @@ def tr(self, message):
         :returns: Translated version of message.
         :rtype: QString
         """
-        # noinspection PyTypeChecker,PyArgumentList,PyCallByClass
-        return QCoreApplication.translate("GoogleEarthEngine", message)
+        return utils.translate(message)
 
     def initGui(self):
         """Initialize the plugin GUI."""
@@ -116,36 +116,52 @@ def initGui(self):
             parent=self.iface.mainWindow(),
             triggered=self._run_cmd_set_cloud_project,
         )
+        add_fc_button = QtWidgets.QAction(
+            text=self.tr("Add Feature Collection"),
+            parent=self.iface.mainWindow(),
+            triggered=lambda: add_feature_collection.form(
+                self.iface,
+                accepted=add_feature_collection.callback,
+            ),
+        )
 
-        # Build plugin menu
+        # Initialize plugin menu
         plugin_menu = cast(QtWidgets.QMenu, self.iface.pluginMenu())
-        ee_menu = plugin_menu.addMenu(
+        self.menu = plugin_menu.addMenu(
             icon("earth-engine.svg"),
             self.tr("&Google Earth Engine"),
         )
-        self.menu = ee_menu
-        ee_menu.addAction(ee_user_guide_action)
-        ee_menu.addSeparator()
-        ee_menu.addAction(sign_in_action)
-        ee_menu.addAction(self.set_cloud_project_action)
-
-        # Build toolbar
-        toolButton = QtWidgets.QToolButton()
-        toolButton.setToolButtonStyle(
-            Qt.ToolButtonStyle.ToolButtonIconOnly
-            # Qt.ToolButtonStyle.ToolButtonTextBesideIcon
+
+        # Initialize toolbar menu
+        self.toolButton = QtWidgets.QToolButton()
+        self.toolButton.setToolButtonStyle(Qt.ToolButtonStyle.ToolButtonIconOnly)
+        self.toolButton.setPopupMode(
+            QtWidgets.QToolButton.ToolButtonPopupMode.InstantPopup
         )
-        toolButton.setPopupMode(
-            QtWidgets.QToolButton.ToolButtonPopupMode.MenuButtonPopup
+        self.toolButton.setMenu(QtWidgets.QMenu())
+        self.toolButton.setDefaultAction(
+            QtWidgets.QAction(
+                icon=icon("earth-engine.svg"),
+                text=f'<strong>{self.tr("Google Earth Engine")}</strong>',
+                parent=self.iface.mainWindow(),
+            )
         )
-        toolButton.setMenu(QtWidgets.QMenu())
-        toolButton.setDefaultAction(ee_user_guide_action)
-        toolButton.menu().addAction(ee_user_guide_action)
-        toolButton.menu().addSeparator()
-        toolButton.menu().addAction(sign_in_action)
-        toolButton.menu().addAction(self.set_cloud_project_action)
-        self.iface.pluginToolBar().addWidget(toolButton)
-        self.toolButton = toolButton
+        self.iface.pluginToolBar().addWidget(self.toolButton)
+
+        # Add actions to the menu
+        for action in [
+            ee_user_guide_action,
+            None,
+            sign_in_action,
+            self.set_cloud_project_action,
+            None,
+            add_fc_button,
+        ]:
+            for menu in [self.menu, self.toolButton.menu()]:
+                if action:
+                    menu.addAction(action)
+                else:
+                    menu.addSeparator()
 
         # Register signal to initialize EE layers on project load
         self.iface.projectRead.connect(self._updateLayers)

ee_plugin/ui/forms/add_feature_collection.py

@@ -0,0 +1,168 @@
+from typing import Optional, Callable
+from qgis import gui
+from qgis.PyQt import QtWidgets
+import ee
+
+from ..utils import (
+    build_form_group_box,
+    build_vbox_dialog,
+    call_func_with_values,
+    DefaultNullQgsDateEdit,
+)
+
+from ... import Map, utils
+from ...utils import translate as _
+
+
+def form(
+    iface: gui.QgisInterface,
+    accepted: Optional[Callable] = None,
+    **dialog_kwargs,
+) -> QtWidgets.QDialog:
+    """Add a GEE Feature Collection to the map."""
+    dialog = build_vbox_dialog(
+        windowTitle=_("Add Feature Collection"),
+        widgets=[
+            build_form_group_box(
+                title=_("Source"),
+                rows=[
+                    (
+                        QtWidgets.QLabel(
+                            toolTip=_("The Earth Engine Feature Collection ID."),
+                            text="<br />".join(
+                                [
+                                    _("Feature Collection ID"),
+                                    "e.g. <code>USGS/WBD/2017/HUC06</code>",
+                                ]
+                            ),
+                        ),
+                        QtWidgets.QLineEdit(
+                            objectName="feature_collection_id",
+                        ),
+                    ),
+                    (
+                        QtWidgets.QLabel(
+                            _("Retain as a vector layer"),
+                            toolTip=_(
+                                "Store as a vector layer rather than WMS Raster layer."
+                            ),
+                            whatsThis=_(
+                                "Attempt to retain the layer as a vector layer, running "
+                                "the risk of encountering Earth Engine API limitations if "
+                                "the layer is large. Otherwise, the layer will be added as "
+                                "a WMS raster layer."
+                            ),
+                        ),
+                        QtWidgets.QCheckBox(
+                            objectName="as_vector",
+                        ),
+                    ),
+                ],
+            ),
+            build_form_group_box(
+                title=_("Filter by Properties"),
+                collapsable=True,
+                collapsed=True,
+                rows=[
+                    (
+                        _("Name"),
+                        QtWidgets.QLineEdit(objectName="filter_name"),
+                    ),
+                    (
+                        _("Value"),
+                        QtWidgets.QLineEdit(objectName="filter_value"),
+                    ),
+                ],
+            ),
+            build_form_group_box(
+                title=_("Filter by Dates"),
+                collapsable=True,
+                collapsed=True,
+                rows=[
+                    (
+                        "Start",
+                        DefaultNullQgsDateEdit(objectName="start_date"),
+                    ),
+                    (
+                        "End",
+                        DefaultNullQgsDateEdit(objectName="end_date"),
+                    ),
+                ],
+            ),
+            gui.QgsExtentGroupBox(
+                objectName="extent",
+                title=_("Filter by Coordinates"),
+                collapsed=True,
+            ),
+            build_form_group_box(
+                title=_("Visualization"),
+                collapsable=True,
+                collapsed=True,
+                rows=[
+                    (
+                        _("Color"),
+                        gui.QgsColorButton(objectName="viz_color_hex"),
+                    ),
+                ],
+            ),
+        ],
+        parent=iface.mainWindow(),
+        **dialog_kwargs,
+    )
+
+    if accepted:
+        dialog.accepted.connect(lambda: call_func_with_values(accepted, dialog))
+    return dialog
+
+
+def callback(
+    feature_collection_id: str,
+    filter_name: str,
+    filter_value: str,
+    start_date: Optional[str],
+    end_date: Optional[str],
+    extent: Optional[tuple[float, float, float, float]],
+    viz_color_hex: str,
+    as_vector: bool,
+):
+    """
+    Loads and optionally filters a FeatureCollection, then adds it to the map.
+
+    Args:
+        feature_collection_id (str): The Earth Engine FeatureCollection ID.
+        filter_name (str, optional): Name of the attribute to filter on.
+        filter_value (str, optional): Value of the attribute to match.
+        start_date (str, optional): Start date (YYYY-MM-DD) for filtering (must have a date property in your FC).
+        end_date (str, optional): End date (YYYY-MM-DD) for filtering (must have a date property in your FC).
+        extent (ee.Geometry, optional): Geometry to filter (or clip) the FeatureCollection.
+        viz_color_hex (str, optional): Hex color code for styling the features.
+
+    Returns:
+        ee.FeatureCollection: The filtered FeatureCollection.
+    """
+
+    fc = ee.FeatureCollection(feature_collection_id)
+
+    if filter_name and filter_value:
+        fc = fc.filter(ee.Filter.eq(filter_name, filter_value))
+
+    if start_date and end_date:
+        fc = fc.filter(ee.Filter.date(ee.Date(start_date), ee.Date(end_date)))
+
+    if extent:
+        fc = fc.filterBounds(ee.Geometry.Rectangle(extent))
+
+    # 6. Add to map
+    layer_name = f"FC: {feature_collection_id}"
+    if as_vector:
+        try:
+            utils.add_ee_vector_layer(fc, layer_name)
+        except ee.ee_exception.EEException as e:
+            Map.get_iface().messageBar().pushMessage(
+                "Error",
+                f"Failed to load the Feature Collection: {e}",
+                level=gui.Qgis.Critical,
+            )
+    else:
+        Map.addLayer(fc, {"palette": viz_color_hex}, layer_name)
+    return fc